Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

思路：

二分转化为两个链表的归并，复杂度为（kn）。

代码：

    ListNode *merge2Lists(ListNode *l1, ListNode *l2){
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        ListNode *result, *head = NULL;
        if(l1->val < l2->val){
            head = l1;
            l1 = l1->next;
        }            
        else{
            head = l2;
            l2 = l2->next;
        }
        result = head;
        while(l1 && l2){
            if(l1->val < l2->val){
                result->next = l1;
                l1 = l1->next;
            }
            else{
                result->next = l2; 
                l2 = l2->next;
            }
            result = result->next;
        }
        if(l1 == NULL)
            result->next = l2;
        else
            result->next = l1;
        return head;
    }
    ListNode *mergeKLists(vector<ListNode *> &lists, int start, int end){
        if(start >= end)
            return NULL;
        if(end == start+1)
            return lists[start];
        if(end == start+2){
            ListNode *l1 = lists[start];
            ListNode *l2 = lists[start+1];
            return merge2Lists(l1, l2);
        }
        else{
            ListNode *l1 = mergeKLists(lists, start, (start+end)/2);
            ListNode *l2 = mergeKLists(lists, (start+end)/2, end);
            return merge2Lists(l1, l2);
        }
    }
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        return mergeKLists(lists, 0, lists.size());
    }

 另外一种方法是使用堆，可是使得复杂度变为O（nlgk）。这里堆可以自己实现，也可以用STL中的priority_queue。

在下面代码，一方面要学习priority_queue的使用，另一方面要注意那个虚头head的使用，这样可以避免对head是否为NULL的判断。另外一种解决的类似方法的手段是用一个**指针指向head，然后不断更新**，最后返回**指针指向的指针。

    struct cmp{
        bool operator()(ListNode *a, ListNode *b){
            return a->val > b->val;
        }
    };
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        priority_queue<ListNode*, vector<ListNode*>, cmp > pq;
        int i;
        for(i = 0; i < lists.size(); i++){
            if(lists[i])
                pq.push(lists[i]);
        }
        ListNode *head = new ListNode(0), *cur = head;
        while(!pq.empty()){
            ListNode *tmp = pq.top();
            cur->next = tmp;
            cur = cur->next;
            pq.pop();
            if(tmp->next)
                pq.push(tmp->next);
        }
        return head->next;
    }