从头做leetcode之leetcode 23 合并k个有序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

暴力法

• 先用最容易想的办法，将k个链表的合并转化成k-1次两个链表的合并，利用之前做过的合并两个有序链表的算法
  时间复杂度:O((k-1)*lists[0].size()+(k-2)lists[1].size()+ ··· +list[k-1].size())。

/**
 - Definition for singly-linked list.
 - struct ListNode {
 -     int val;
 -     ListNode *next;
 -     ListNode(int x) : val(x), next(NULL) {}
 - };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *res=new ListNode;
        ListNode *p=res;
        if(l2==NULL) return l1;
        if(l1==NULL) return l2;
        while(l1 && l2){
            if(l1->val <= l2->val){
                p->next=l1;
                l1=l1->next;
            }
            else{
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        if(l1){
            p->next=l1;
        }
        if(l2){
            p->next=l2;
        }
        return res->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        ListNode *finalres=new ListNode;
        finalres=lists[0];
        for(int i=1;i<lists.size();i++){
            finalres=mergeTwoLists(finalres,lists[i]);
        }
        return finalres;
    }
};

通过时间：

采用分治法优化

• 类似于归并排序，分别对中值两侧的元素进行归并，一直到两个链表归并，最后再整合到一起

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *res=new ListNode;
        ListNode *p=res;
        if(l2==NULL) return l1;
        if(l1==NULL) return l2;
        while(l1 && l2){
            if(l1->val <= l2->val){
                p->next=l1;
                l1=l1->next;
            }
            else{
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        if(l1){
            p->next=l1;
        }
        if(l2){
            p->next=l2;
        }
        return res->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        ListNode *finalres=new ListNode;
        finalres=lists[0];
        vector<ListNode*> leftlists,rightlists;
        for(int i=0;i<lists.size()/2;i++){
            leftlists.push_back(lists[i]);
        }
        int j=0;
        for(int i=lists.size()/2;i<lists.size();i++){
            rightlists.push_back(lists[i]);
            j++;
        }
        return mergeTwoLists(mergeKLists(leftlists),mergeKLists(rightlists));
    }
};

通过时间：

小顶堆（优先队列）

• 用构造一个小顶堆的方法，将每个链表的第一个结点放入优先队列中，每次弹出堆顶元素放入结果链表中，然后将堆顶元素的next结点（如果存在）放入优先队列。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
struct Listcompare{//自己写一个优先队列的比较函数
    bool operator()(ListNode* l1,ListNode* l2){
        return l1->val > l2->val;
    }
};
class Solution {
public:
        ListNode* mergeKLists(vector<ListNode*> &lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()==1) return lists[0];
        priority_queue<ListNode*, vector<ListNode*>, Listcompare> heap;
        for (int i=0;i<lists.size();i++) {
            if(lists[i]!=NULL){//注意有些测试用例中的空链表
                heap.push(lists[i]);
            }
        }
        ListNode *res = new ListNode, *p = res;
        while (!heap.empty()) {
            ListNode *temp = heap.top();
            heap.pop();
            p->next = temp;
            if (temp->next) heap.push(temp->next);
            p = p->next;
        }
        return res->next;
    }
};

通过时间：