Merge k Sorted Lists

原题链接：https://leetcode.com/problems/merge-k-sorted-lists/description/

题目要求将k个已排好序（升序）的链表，合并成一个有序的链表。

Solution1： 第一种方法就是，用分治法，先将这k个list两两合并，得到k/2个长度为2n的新链表；然后继续将这k/2个链表两两合并，直到最后合并成一个链表。

ListNode* mergeKLists(vector<ListNode*>& lists) {        int k = lists.size();        if (k == 0) return NULL;        if (k == 1) return lists[0];        vector<ListNode*> A(lists.begin(), lists.begin() + k/2);        vector<ListNode*> B(lists.begin() + k/2, lists.end());        ListNode* list_A = mergeKLists(A);        ListNode* list_B = mergeKLists(B);        ListNode *result = NULL, *tempNode;        while(list_A || list_B) {  // list 都是升序            if (!list_A) {                                if (!result) {                    result = new ListNode(list_B->val);                    result -> next  = list_B -> next;                } else {                    tempNode->next = list_B;                }                break;            }            if (!list_B) {                while (list_A) {                    if (!result) {                        result = new ListNode(list_A->val);                        tempNode = result;                    } else {                        tempNode->next = new ListNode(list_A->val);                        tempNode = tempNode -> next;                    }                    list_A = list_A -> next;                }                break;            }            int value_A = list_A->val;            int value_B = list_B->val;            if (!result) {                result = new ListNode(min(value_A, value_B));                tempNode = result;            } else {                tempNode->next = new ListNode(min(value_A, value_B));                tempNode = tempNode -> next;            }            if (value_A < value_B) list_A = list_A -> next;             else list_B = list_B -> next;        }        return result;    }

算法复杂度： 假设k个list共有N个节点，则复杂度为O（Nlogk）。

Solution2： 可以使用priority_queue这种数据结构，因为priority_queue的第一个元素是它所包含的元素中最大或最小的。将k个list中所有节点的数据都存入priority_queue中，并根据这个priority_queue重新生成一个链表。

struct compareNodes {    bool operator()(const int a, const int b) {        return a > b;    }};class Solution {public:    ListNode* mergeKLists(vector<ListNode*>& lists) {        priority_queue<int, vector<int>, compareNodes> p;        for (auto l : lists) {            while (l) {                p.push(l -> val);                l = l->next;            }        }        ListNode* result = NULL, *tail;        if (!p.empty()) {            result = new ListNode(p.top());            tail = result;            p.pop();        }        while (!p.empty()) {            tail -> next = new ListNode(p.top());            tail = tail -> next;            p.pop();        }        return result;    }};

算法复杂度： 查找优先队列中的最小值，需要O(1)，插入和删除需要O(logN)，其中N为优先队列中元素个数。所以，假设k个list共有N个节点，这种方法的复杂度为O(NlogN)。
改进：若在k路归并中使用优先队列来选择最小值，则只需要构建一个长度为k的优先队列，因此时间复杂度可以达到O(Nlogk)。