23. Merge k Sorted Lists

题意：Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
分析：堆排序
AC代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* ret = NULL, *p = NULL;

        if(lists.size() == 0){
            return ret;
        }
        if(lists.size() == 1){
            return lists[0];
        }
        buildHeap(lists);

        while(lists.size() != 0){
            if(!ret){
                ret = lists[0];
                p = ret;
            }else{
                p->next = lists[0];
                p = p->next;
            }
            if(lists[0]->next){
                lists[0] = lists[0]->next;
                MinHeapify(lists, 0);
            }else{
                lists[0] = lists[lists.size() - 1];
                MinHeapify(lists, 0);
                lists.pop_back();
            }
        }

        return ret;

    }
    void buildHeap(vector<ListNode*>& lists){
        for(int i = lists.size() / 2; i >= 0; --i){
            MinHeapify(lists, i);
        }
    }

    void MinHeapify(vector<ListNode*> &lists, int i){
        while(i < lists.size() && !lists[i]){
            if(i != lists.size() - 1)
                lists[i] = lists[lists.size() - 1];
            lists.pop_back();
        }
        int left = 2 * i + 1;

        int right = 2 * (i + 1);
        int min = i;

        while(left < lists.size() && !lists[left] && lists.size() != 0){
            lists[left] = lists[lists.size() - 1];
            lists.pop_back();
        }
        if(left < lists.size() && lists[i]->val > lists[left]->val)
            min = left;

        while(right < lists.size() && !lists[right] && lists.size() != 0){
            lists[right] = lists[lists.size() - 1];
            lists.pop_back();
        }
        if(right < lists.size() && lists[min]->val > lists[right]->val)
            min = right;

        if(min != i){
            ListNode* tmp = lists[min];
            lists[min] = lists[i];
            lists[i] = tmp;
            MinHeapify(lists, min);
        }
    }
};