Leetcode OJ: Merge Two Sorted Lists、Merge k Sorted Lists

这一篇是两个全集，从2个排序列表到k个排序列表。

先从2个入手。

Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

思路跟数组时类似，主要都是比较、链表插入操作。

代码如下：

/**
 * 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* ret = NULL;
        ListNode* pre = NULL;
        while (l1 != NULL && l2 != NULL) {
            if (l1->val < l2->val) {
                ListNode* tmp = l1->next;
                l1->next = NULL;
                if (ret == NULL) {
                    ret = l1;
                    pre = ret;
                } else {
                    pre->next = l1;
                    pre = l1;
                }
                l1 = tmp;
            } else {
                ListNode* tmp = l2->next;
                l2->next = NULL;
                if (ret == NULL) {
                    ret = l2;
                    pre = ret;
                } else {
                    pre->next = l2;
                    pre = l2;
                }
                l2 = tmp;
            }
        }
        if (l1 != NULL) {
            // 判断l1、l2中是否存在空链表
            if (pre != NULL)
                pre->next = l1;
            else
                ret = l1;
        }
        if (l2 != NULL) {
            // 判断l1、l2中是否存在空链表
            if (pre != NULL)
                pre->next = l2;
            else
                ret = l2;
        }
        return ret;
    }
};

别忘了检查存在空链表的情况。空间复杂度为O(1)，时间复杂度为O(m+n)。

由2个列表变成k的列表又有什么变化呢？

Merge k Sorted Lists

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

按照以上的思路，还是要比较，只是k个List一起比较。

如果是求最大值，最简单的情况就是每个list的头都比较一下，即进行k次比较，要合并完，复杂度为O(k(m+n))。

但是每次比较k次是不是有点慢呢？在这里，我们需要的是每次都得到最大值，第一反应就想到堆了。

于是思路就来了：

1. 先给各List头列一个小根堆

2. 取top，调整，把top插入到输出的链表中，然后把top->next插入堆中，循环这一步至堆空为止。

这里我们直接就用priority_queue，另外还需要定义一个比较类。代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

// 小根堆的比较类
class Greater {
public:
    bool operator() (const ListNode* a, const ListNode* b) const {
        return a->val > b->val;
    }
};

class Solution {
public:
    
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        priority_queue<ListNode*, vector<ListNode*>, Greater> heap;
        // 先把非NULL的ListNode给清掉，放进堆中
        for (vector<ListNode*>::iterator it = lists.begin();
            it != lists.end(); ++it) 
        {
            if ((*it) != NULL)
                heap.push(*it);
        }
        ListNode* head = NULL;
        ListNode* pre = NULL;
        while (!heap.empty()) {
            ListNode* tmp = heap.top();
            heap.pop();
            if (tmp->next != NULL)
                heap.push(tmp->next);
            if (head == NULL) {
                head = tmp;
                pre = tmp;
                continue;
            }
            pre->next = tmp;
            pre = tmp;
        }
        return head;
    }
};