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;
    }
};