LeetCoder_____合并K个链表(23)

1. 话外

工作之后好久没有刷Leetcode，今天发现已经有中文官网了，好的地方是看题不需要Google翻译了。

2. 思路

看题意，很简单是个归并排序，不过真的是一直沉迷业务代码，好久没有写过算法，竟一时有点“卡住”，不过还好很快就能写出来。

这个题目在时间算法度O(nlogk)的要求下，主要有两个实现思路:

1. 每次取K个链表头中最小的一个加入到新链表中，每次比较K，一共N次比较。复杂度是O(nk)；但是如果使用堆去维护链表头，可以logk的复杂度得到最小的链表头，所以可以达到O(nlogk)。合理利用原来的节点空间，可以达到空间复杂度O(1)。
2. 分治的思路，两两将链表合并，时间复杂度O(nlogk)；合理利用原来的节点空间，可以达到空间复杂度O(1)。

3. 代码

这里我使用的是第2种方法：

/**
 * 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) {
        
        
        if(lists.size() == 0)
        {
            return NULL;
        }
        
        merge2Lists(lists, 0, lists.size() - 1);
        
        return lists[0];
    }
    
    
    
private:
    
    void merge2Lists(vector<ListNode*>& lists, int left, int right) {
        
        if(left >= right)
        {
            return;
        }
        
        if(left < right - 1)
        {
            int mid = (left + right) >> 1;
            merge2Lists(lists, left, mid);
            merge2Lists(lists, mid + 1, right);
            right = mid + 1;
        }
        
        
        ListNode *f1 = lists[left], *f2 = lists[right], *root = NULL, *cur = NULL;
        
        if(f1 == NULL)
        {
            lists[left] = f2;
            return;
        }
        if(f2 == NULL)
        {
            return;
        }
        
        
        while(f1 != NULL || f2 != NULL)
        {
            if(f1 == NULL)
            {
                cur->next = f2;
                break;
            }
            if(f2 == NULL)
            {
                cur->next = f1;
                break;
            }
            ListNode* minNode = f1;
            if(f1->val <= f2->val)
            {
                minNode = f1;
                f1 = f1->next;
            }
            else
            {
                minNode = f2;
                f2 = f2->next;
            }
            
            if(root == NULL)
            {
                cur = root = minNode;
            }
            else
            {
                cur->next = minNode;
                cur = minNode;
            }
        }
        lists[left] = root;
    }
    
};