力扣hot100：23. 合并 K 个升序链表

23. 合并 K 个升序链表

这题非常容易想到归并排序的思路，俩升序序列合并，可以使用归并的方法。

不过这里显然是一个多路归并排序；包含多个子数组的归并算法，这可以让我们拓展归并算法的思路。

假设n是序列个数，ni是单个序列长度，length是单个序列最大长度

1、顺序单次归并

从左往右依次进行归并，但是这种方法存在一定的缺点。假设n是序列个数，ni是单个序列长度，根据题设，这个方法的最大比较次数至少是：
$n1+(n1+n2)+(n1+n2+n3)\cdot \cdot \cdot =n\ast n1+(n-1)\ast n2+(n-2)\ast n3\cdot \cdot \cdot <=n\ast (n1+n2+n3+\cdot \cdot \cdot )=n^2\ast length<=10^4\ast 500\ast 10^4$
这相当于每个序列都需要被比较序列个数次，这换成是多路归并的数组合并也是一样的。

官方：

class Solution {
public:ListNode* mergeKLists(vector<ListNode*>& lists) {ListNode * head = nullptr;for(int i = lists.size() - 1;i >= 0; --i){head = merge(head, lists[i]);ListNode * temp = head;}return head;}
private:ListNode * merge(ListNode * p,ListNode * q){if(!p) return q;if(!q) return p;ListNode * head = p;if(head->val > q->val) head = q;if(head == p) p = p->next;else q = q->next;ListNode * temp = head;while(p && q){if(p->val > q->val){head->next = q;q = q->next;}else{head->next = p;p = p->next;}head = head->next;}head->next = p ? p : q;return temp;}
};

2、分治归并

使用分治的思想排序是很容易想到的，但是不能很容易的知道分治归并速度一定更快，接下来让我详细思考一下是否会更快：
我们可以考虑，每次将序列数量减半合并，那么每一层合并使用的时间是$O(length\ast n)$，我们知道每层数量减半，那么一共是有$O(logn)$层，所以时间复杂度为$O(nlogn\ast length)$

为什么分治归并会比普通顺次归并要快？
可以这样看一下，使用分治，将所有数分为两个区间[l,mid]和[mid+1,r]，左区间的数 和 右区间的数只会在最后合并时比较一次，其他时候打死不相往来。而使用顺序归并，左区间的数 和 右区间的数会比较很多次，在考虑到

class Solution {
public:ListNode* mergeKLists(vector<ListNode*>& lists) {if(lists.size() == 0) return nullptr;return mergesort(lists, 0, lists.size() - 1);}
private:ListNode * merge(ListNode * p,ListNode * q){if(!p) return q;if(!q) return p;ListNode * head = p;if(head->val > q->val) head = q;if(head == p) p = p->next;else q = q->next;ListNode * temp = head;while(p && q){if(p->val > q->val){head->next = q;q = q->next;}else{head->next = p;p = p->next;}head = head->next;}head->next = p ? p : q;return temp;}ListNode * mergesort(vector<ListNode*>& lists,int left,int right){if(left == right) return lists[left];int mid = (left + right) >> 1;ListNode * p = mergesort(lists,left,mid);ListNode * q = mergesort(lists,mid + 1, right);return merge(p, q);}
};

3、使用优先队列合并

这种方式非常牛。

我们将所有序列，依据序列头部的元素大小放入一个优先队列，那么这个优先队列的深度是$logn$，然而我们每次取出一个结点它的头部必然是现在里面最小的，将它放入待合并的目标序列中，然后将该序列后移一位，插入到优先队列中。因此每个元素插入时间是$O(logn)$，一共有$(length\ast n)$个元素。所以总时间为$O(nlogn\ast length)$

class Solution {
public:ListNode* mergeKLists(vector<ListNode*>& lists) {if(lists.size() == 0) return nullptr;priority_queue<ListNode *,vector<ListNode *>,Sort> q;for(int i = lists.size() - 1;i >= 0; --i) if(lists[i]) q.push(lists[i]);ListNode * dummy = new ListNode;ListNode * temp = dummy;while(!q.empty()){ListNode * head = q.top();q.pop();temp->next = head;temp = temp->next;head = head->next;if(head) q.push(head);}temp = dummy->next;delete dummy;return temp;}
private:struct Sort{bool operator ()(const ListNode * a,const ListNode * b){return a->val > b->val;}};
};

能够实现优先队列，那么这个问题就很容易被解决。

• 我们需要注意两个问题
  • 优先队列使用的比较函数必须自定义为结构体或者符号重载
  • 优先队列使用的比较函数的大于号小于号取值，和sort刚好相反。

使用方式：

priority_queue<Exp,vector<Exp>,cmp> q;

struct cmp{bool operator() (Exp a, Exp b){if() return true;return false;}
}

唯一变化的就是括号里面的类型Exp和你想要定义的比较方式。