LeetCode 23. 合并K个排序链表

题目描述：

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

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

思路1：遍历所有的链表，把链表里面的值添加到容器里面，然后排序容器。但是使用这种方法的话，如果链表里面的值很多，那么排序的时间复杂度就会很高，所以，不建议这么做

代码1：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty())
            return NULL;
        
        vector<int> val;
        ListNode* p;
        for(int i=0; i<lists.size(); ++i){
            p=lists[i];
            while(p!=NULL){
                val.push_back(p->val);
                p=p->next;
            }
        }
        
        if(val.size()==0)
            return NULL;

        sort(val.begin(), val.end());
        
        ListNode* head=new ListNode(-1);
        p=head;
        for(int i=0; i<val.size(); ++i)
        {
            ListNode *node=new ListNode(val[i]);
            p->next=node;
            p=p->next;
        }
        head=head->next;
        return head;
    }
};

思路二：因为是排序链表，所以我们每次都比较这k个链表的第一个数，这个第一个数中肯定有一个数是最小的，我们只需要构建一个小顶堆，然后只需要取最小的值，然后把对应链表的指针向后移一位，然后调整堆，再把最小的值给调上去，直到链表合并完成。这样的话我们就只需要维护一个规模为k的堆即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int k=lists.size();
        if(k==0)
            return NULL;
        
        
        vector<ListNode*> listIndexs = lists;       
        priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > >pq;//构建一个递增的优先队列
        
        for(int i=0; i<listIndexs.size(); ++i){
            if(lists[i]!=NULL)
                pq.push(pair<int, int>(lists[i]->val, i));            
        }
        
        ListNode* newHead=new ListNode(-1);
        ListNode* p=newHead;
        int val;
        int index;
        while(!pq.empty()){
            val=pq.top().first;
            index=pq.top().second;
            pq.pop();
            
            ListNode* newNode=new ListNode(val);
            p->next=newNode;
            p=p->next;
            
            if(listIndexs[index]->next==NULL)
                continue;
            else
                listIndexs[index]=listIndexs[index]->next;
            
            pq.push(pair<int, int>(listIndexs[index]->val, index));  
        }
        
        return newHead->next;
    }
};