【每日一题】LeetCode 23.合并k个排序链表

每日一题，防止痴呆 = =

一、题目大意

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

示例:
输入:

输出: 1->1->2->3->4->4->5->6

二、题目思路以及AC代码

每日一题的题目都是一如既往的简洁。 = =

这个题目我第一个思路就是暴力，题目要求合并K个有序子链表嘛，这其实就是归并排序的链表版，然而我还是想先试试暴力是不是可以，也就是先合并前两个，然后用结果再去与第三个合并，以此类推… 看起来是可行的，但由于我在写两个链表合并的时候比较随意，所以造成超时了，无奈我就继续考虑别的更快的实现了。

第二个想法就是归并排序的思想，上面那种暴力的方法无疑是有许多重复计算的，所以考虑先对前两个进行合并，然后对第三个和第四个进行合并，然后是第五个和第六个，最后再把这些结果继续按照这种方式进行合并，就可以得到最后的结果了，当然你可以完全按照归并排序的方式去写代码，这里我是直接用了一个队列解决的。

第三个想法也比较容易想到，就是把两个链表合并的思想扩展到多个。两个有序链表排序的时候，无非是用两个指针，分别先指向两个链表的第一个元素，然后比较大小，小的加入，再移动指针，再比较大小… 对于多个链表合并其实也可以和两个类似，我们保存所有子链表的头一个元素，比较大小，最小的放入，并且移动指针，再比较大小，最小的放入，移动指针，直到所有子链表的元素被加入完毕，当然，我觉得没必要这么麻烦 = =，还是归并排序的思想比较好写，也好理解。

下面给出AC代码：（其中只有第二种想法是我自己实现的，其余均是搬运LeetCode的官方解答）

暴力：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *ans = nullptr;
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

作者：LeetCode
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/he-bing-kge-pai-xu-lian-biao-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

归并排序：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
ListNode* merge_2_lists(ListNode* root1, ListNode* root2) {
    if (!root1 || !root2) return root1 ? root1 : root2;

    ListNode head;
    ListNode* p = &head;
    while(root1 && root2) {
        if (root1->val <= root2->val) {
            p->next = root1;
            root1 = root1->next;
        }
        else {
            p->next = root2;
            root2 = root2->next;
        }
        p = p->next;
    }

    p->next = root1 ? root1 : root2;

    return head.next;
}

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int l_size = lists.size();
        if (l_size == 0) return NULL;

        queue<ListNode*> q;
        for (int i=0;i<l_size;i++) {
            q.push(lists[i]);
        }

        while (q.size() > 1) {
            ListNode* one = q.front(); q.pop();
            ListNode* another = q.front(); q.pop();

            ListNode* merge = merge_2_lists(one, another);
            q.push(merge);
        }

        return q.front();
    }
};

两个链表方法扩展

class Solution {
public:
    struct Status {
        int val;
        ListNode *ptr;
        bool operator < (const Status &rhs) const {
            return val > rhs.val;
        }
    };

    priority_queue <Status> q;

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
            if (node) q.push({node->val, node});
        }
        ListNode head, *tail = &head;
        while (!q.empty()) {
            auto f = q.top(); q.pop();
            tail->next = f.ptr; 
            tail = tail->next;
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};

作者：LeetCode
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/he-bing-kge-pai-xu-lian-biao-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

如果有问题，欢迎大家指正！！！