Merge k Sorted Lists

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

类似于归并排序的处理，这里将一个个链表看成一个个有序的元素。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //模拟归并排序
    ListNode* merge(ListNode *a, ListNode *b)
    {
        ListNode *head = NULL, *tmpNodea = a, *tmpNodeb = b, *lastNode = NULL, *tmpNode = NULL;
        while(tmpNodea != NULL && tmpNodeb != NULL)
        {
            if(tmpNodea->val < tmpNodeb->val)
            {
                tmpNode = tmpNodea;
                tmpNodea = tmpNodea->next;
            }
            else
            {
                tmpNode = tmpNodeb;
                tmpNodeb = tmpNodeb->next;
            }
            
            if(head == NULL)
            {
                head = tmpNode;
                lastNode = head;
            }
            else
            {
                lastNode->next = tmpNode;
                lastNode = lastNode->next;
            }
        }
        
        while(tmpNodea != NULL)
        {
            if(head == NULL)
            {
                head = tmpNodea;
                lastNode = head;
                tmpNodea = tmpNodea->next;
            }
            else
            {
                lastNode->next = tmpNodea;
                lastNode = lastNode->next;
                tmpNodea = tmpNodea->next;
            }
        }
        
        while(tmpNodeb != NULL)
        {
            if(head == NULL)
            {
                head = tmpNodeb;
                lastNode = head;
                tmpNodeb = tmpNodeb->next;
            }
            else
            {
                lastNode->next = tmpNodeb;
                lastNode = lastNode->next;
                tmpNodeb = tmpNodeb->next;
            }
        }
        
        if(lastNode != NULL)
            lastNode->next = NULL;
        return head;
    }
    
    ListNode* mergeKLists(vector<ListNode *> &lists, int low, int high)
    {
        if(low > high)
            return NULL;
        if(low == high)
            return lists[low];
        
        int mid = (low + high) / 2;
        ListNode *lhead = mergeKLists(lists, low, mid);
        ListNode *rhead = mergeKLists(lists, mid + 1, high);
        return merge(lhead, rhead);
    }
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int len = lists.size();
        if(len < 1)
            return NULL;
        if(len == 1)
            return lists[0];
        return mergeKLists(lists, 0, len - 1);
    }
};