LeetCode 23. Merge k Sorted Lists（合并k个有序单链表）

题目描述：
    Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
分析：
    题意：给定k个有序单链表，把他们合并成为一个有序单链表并返回。
    思路：这道题是LeetCode 21的进化版本。看到这道题，脑海里首先联想到的是归并排序（Merge Sort）：如果我们把k个单链表看成是k个有序子段数组，那么接下来就是对每两个有序数组进行合并（Merge）的过程了。
    也就是说，LeetCode 23对应单链表的归并排序，而LeetCode 21对应单链表的归并排序中的合并过程！
    假设k个单链表中，平均每个单链表包含n个结点，那么平均时间复杂度为O(nlog(k))。
代码：
#include <bits/stdc++.h>

using namespace std;

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

class Solution {
private:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
// Exceptional Case:
if(!l1){
return l2;
}
if(!l2){
return l1;
}
ListNode *h = new ListNode(-1), *pre = h;
ListNode *p = l1, *q = l2;
// merge
while(p && q){
if(p->val < q->val){
pre->next = p;
pre = p;
p = p->next;
}
else{
pre->next = q;
pre = q;
q = q->next;
}
}
// link the rest of l1
if(p){
pre->next = p;
}
// link the rest of l2
if(q){
pre->next = q;
}
return h->next;
}

public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
int n = lists.size();
// Exceptional Case:
if(n == 0){
return NULL;
}
if(n == 1){
return lists[0];
}
if(n == 2){
return mergeTwoLists(lists[0], lists[1]);
}
// divide the lists into two parts
vector<ListNode*> lists_left, lists_right;
lists_left.assign(lists.begin(), lists.begin() + n / 2);
lists_right.assign(lists.begin() + n / 2, lists.end());
// Divide-And-Conquer
ListNode *left = mergeKLists(lists_left);
ListNode *right = mergeKLists(lists_right);
return mergeTwoLists(left, right);
}
};