leetcode 23. Merge k Sorted Lists

 * 相當於歸併排序的歸併部分，參考講解：https://www.youtube.com/watch?v=6bvnZzwiKzs

 有k個有序的鏈表，假設每個鏈表的長度爲n，將這k個鏈表合併成一個

 有序鏈表。

 一種方法是，直接拼接這k個鏈表後再排序，複雜度是O(KN*LOG(KN))；

 另一種方法是，每次在k個鏈表中選出排在第一的最小的元素，如此下去，

 複雜度是O(KN*K)；

 還有一種方法是上一種方法的基礎上加一個priority_queue,可以將複雜度

 降低到O(KN*LOG(K))

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *head = NULL, *tail = NULL;;
        priority_queue<ListNode*, vector<ListNode*>, function<bool(const ListNode * leftPtr, ListNode *rightPtr)>> cachQueue([](const ListNode *leftPtr, const ListNode *rightPtr) {return leftPtr->val < rightPtr->val;});
        for (int i = 0; i < lists.size(); i++) {
            if (lists[i] != NULL) {
                cachQueue.push(lists[i]);
                lists[i] = lists[i]->next;
            }
        }
        if (!cachQueue.empty()) {
            head = cachQueue.top();
            cachQueue.pop();
            if (head->next != NULL) {
                cachQueue.push(head->next);
            }
            tail = head;
        }
        while (!cachQueue.empty()) {
            ListNode *newPtr = cachQueue.top();
            cachQueue.pop();
            if (newPtr->next != NULL) {
                cachQueue.push(newPtr->next);
            }
            tail->next = newPtr;
            tail = newPtr;
        }
        return head;
    }
};