【Leetcode】【Hard】Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

解题思路：

1、先取出k个list的首元素，每个首元素是对应list中的最小元素，组成一个具有k个结点的最小堆；o(k*logk)

2、此时堆顶元素就是所有k个list的最小元素，将其pop出，并用此最小元素所在list上的下一个结点（如果存在）填充堆顶，并执行下滤操作，重新构建堆。o(logk)

3、不断执行第二步，直到堆中元素为0。o(nlogk)

最终时间复杂度为o(nlogk)，k表示list的个数，n表示所有list总结点数；

解题方法1：

使用C++ make_heap，push_heap，pop_heap函数；

步骤：

1、新建一个结点preHead，指向最终返回结果链表的首结点；新建一个curNode指针，用于操作新建链表；

2、将每个list的首指针装入一个新建的vector v中，注意判断list不为空；

3、调用make_heap函数将这些首指针构造成堆；需要编写greater比较函数；

4、循环操作，只要v不为空：

　　（1）取出堆顶，放入新建链表的末端；

　　（2）pop_heap，交换当前堆首尾元素，并下滤首元素；

　　（3）pop_back，删除v最后一个元素（当前最小元素）；

　　（4）push_back，将当前最小元素的下一个元素加入堆尾；

　　（5）push_heap，对堆尾元素进行上滤；

5、返回preHead->next；

代码：

 /**
  * 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) { //make_heap
         ListNode prehead();
         ListNode *curNode = &prehead;
         vector<ListNode*> v;
         for(int i = ; i < lists.size(); i++){
             if (lists[i])
                 v.push_back(lists[i]);
         }
         make_heap(v.begin(), v.end(), heapComp); //vector -> heap data strcture

         while(v.size() > ){
             curNode->next = v.front();
             pop_heap(v.begin(), v.end(), heapComp);
             v.pop_back();
             curNode = curNode->next;
             if(curNode->next) {
                 v.push_back(curNode->next);
                 push_heap(v.begin(), v.end(), heapComp);
             }
         }

         return prehead.next;
     }

     static bool heapComp(ListNode* a, ListNode* b) {
             return a->val > b->val;
     }
 };

解题方法2：

使用C++ priority_queue 构建最小堆；

步骤和上述基本一致；

代码

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     ListNode *next;
  *     ListNode(int x) : val(x), next(NULL) {}
  * };
  */
 class Solution {
 public:
     struct cmp {
         bool operator()(const ListNode *n1, const ListNode *n2) {
             return n1->val > n2->val;
         }
     };

     ListNode *mergeKLists(vector<ListNode *> &lists) {
         priority_queue<ListNode*, vector<ListNode *>, cmp > heap;
         ListNode pre_head();
         ListNode *curNode = &pre_head;
         for (int i = ; i < lists.size(); i++) {
             if (lists[i])
                 heap.push(lists[i]);
         }

         while (!heap.empty()){
             curNode->next = heap.top();
             heap.pop();
             curNode = curNode->next;
             if (curNode->next)
                 heap.push(curNode->next);
         }

         return pre_head.next;
     }
 };