23.Merge k Sorted Lists (Array, Queue; Sort)

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

思路I: 选择排序

每次都比较各个list的头指针所指的val，取最小的那个。时间复杂度O(n*k)

class Solution {
public:
    ListNode *mergeKLists(vector &lists) {
        if(lists.empty()) return NULL;
        ListNode *head = new ListNode(INT_MIN); //创建头指针，不指向任何List元素；最后返回的是head->next
        head->next = lists[0];
        ListNode *p1;
        ListNode *p2;
        ListNode *tmp;
        for(int i = 1; i< lists.size(); i++)
        {
            p1 = head;
            p2 = lists[i];
            while(p1->next && p2)
            {
                if(p1->next->val <= p2->val) p1 = p1->next;
                else
                {
                    tmp = p1->next;
                    p1->next = p2;
                    p1 = p1->next;
                    p2 = p2->next;
                    p1->next = tmp;
                }
            }
            if(p2)
            {
                p1->next = p2;
            }
        }
        return head->next;
    }
};

Result：Time Limit Exceeded

思路II: 最小堆。

时间复杂度：堆排序其实也是一种选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，然后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有很多已经在前面的n-1次比较中已经做过，而树形选择排序恰好利用树形的特点保存了部分前面的比较结果，因此可以减少比较次数。时间复杂度为O(nlogk)

堆排序思想参考：http://jingyan.baidu.com/article/5225f26b057d5de6fa0908f3.html 

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // 使用堆排序, 
        // 1. 选出每个链表的头来插入小顶堆中，
        // 2. 再把堆顶接入合并链表中，
        // 3. 被选出的指针后移再加入小顶堆中,回到2
        // 4. 最后所有链表都为空时，返回合并链表的头指针
        if(lists.empty()) return nullptr;
        vector<ListNode* > heap;
        heap.push_back(0); //padding
        // 1. 选出每个链表的头来插入小顶堆中，
        for(int i = 0; i != lists.size(); i ++){
           if(lists[i]) heap.push_back(lists[i]);
        }
        makeHeap(heap);
        // 2. 再把堆顶接入合并链表中，
        ListNode head(-1); // 合并链表的表头
        ListNode* p = &head;
        while(heap.size()>1){
            auto minNode = heap[1];
            p->next = minNode; // 接入链表
            p = p->next;
            // 3. 被选出的指针后移再加入小顶堆中,回到2
            auto next = minNode->next;
            if(next) {
                heap[1] = next;
            }else{
                swap(heap[1], heap[heap.size()-1]);
                heap.pop_back();
            }
            minHeap(heap, 1);//加入新元素到堆顶后，自上向下调整
        }
        // 4. 最后所有链表都为空时，返回合并链表的头指针
        return head.next;
    }
    // 建立小顶堆
    // 自底向上
    void makeHeap(vector<ListNode*> &heap){
        // 从最后一个元素的父节点开始建立小顶堆
        for(int i = (heap.size()-1)/2; i >0 ; i --){
            minHeap(heap, i);
        }
    }
    // 小顶堆,以第i个元素为根建立小顶堆
    //位置从1开始，取元素时记得-1
    // 自顶向下
    void minHeap(vector<ListNode*> &heap, int i){
        int l = i*2;
        int r = l+1;
        int least(i);
        // 算出最小元素的位置
        if((l< heap.size()) && heap[l]->val<heap[i]->val ){
            // 如果没有超过边界并且左孩子比父亲小，则换
            least = l;
        }
        if(r<heap.size() && heap[r]->val<heap[least]->val){
            // 如果没有超过边界并且右孩子最小，则换
            least = r;
        }
        if(least != i){
            swap(heap[i], heap[least]);
            minHeap(heap, least);//换了之后，继续向下调整
        }
    }
};

C++的优先队列底部就是用堆排序实现的，所以这里可以使用优先队列。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 
struct cmp {
    bool operator () (ListNode *a, ListNode *b) {
        return a->val > b->val;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        priority_queue<ListNode*,vector<ListNode*>,cmp> queue;
        for (int i = 0; i < lists.size(); i++) {
            if (lists[i] != NULL) {
                queue.push(lists[i]);
            }
        }
        
        ListNode *head = new ListNode(INT_MIN);
        ListNode *prev = head, *temp;
        while (!queue.empty()) {
            temp = queue.top();
            queue.pop();
            prev->next = temp;
            prev = prev->next;

            if (temp->next != NULL) {
                queue.push(temp->next);
            }
        }
        return head->next;
    }
};

优先队列默认从大到小排序，即大顶堆，所以这里我们需要改成小顶堆：

1. 基本类型(例如int）都可以用greater<type>声明小顶堆优先队列：

priority_queue<int, vector<int>, greater<int>> q

2. 自定义的数据结构必须自定义比较函数（如以上代码中定义的cmp），或者自定义 > 操作：

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

思路III：归并排序

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

reference: http://baike.baidu.com/link?url=ayX3MQx_CrmcjOxkL7EKhXukLH9pJKJsD1XDMaP6eQwvFfc-BtnQBUTsElRafXbxqhCFOIlKC5VsL14LgjEjIK 

归并排序时间复杂度O(nlogn)

/**
 * 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;
        
        mergeSort(lists, 0, lists.size()-1);
        return lists[0];
    }
    void mergeSort(vector<ListNode*>& lists, int start, int end){
        if(start==end) return;
        int mid = (start + end) >> 1;
        mergeSort(lists, start, mid);
        mergeSort(lists, mid+1, end); 
        merge(lists,start, mid+1);
    }
    
    void merge(vector<ListNode*>& lists, int lst1, int lst2){
        ListNode* root = NULL;
        ListNode* current = NULL;
        
        while(lists[lst1] && lists[lst2]){
            if(lists[lst1]->val <= lists[lst2]->val){
                if(!root){
                    root = lists[lst1];
                    current = root;
                }
                else{
                    current->next = lists[lst1];
                    current = current->next;
                }
                lists[lst1] = lists[lst1]->next;
            }
            else{
                if(!root){
                    root = lists[lst2];
                    current = root;
                }
                else{
                    current->next = lists[lst2];
                    current = current->next;
                }
                lists[lst2] = lists[lst2]->next;
            }
        }
        
        while(lists[lst1]){
            if(!root){
                root = lists[lst1];
                current = root;
            }
            else{
                current->next = lists[lst1];
                current = current->next;
            }
            lists[lst1] = lists[lst1]->next;
        }
        while(lists[lst2]){
            if(!root){
                root = lists[lst2];
                current = root;
            }
            else{
                current->next = lists[lst2];
                current = current->next;
            }
            lists[lst2] = lists[lst2]->next;
        }
        
        lists[lst1] = root;
    }
};