LeetCode之“链表”：Merge Two Sorted Lists && Merge k Sorted Lists

　 1. Merge Two Sorted Lists

　　题目链接

　　题目要求：

 　  Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

　　这道题目题意是要将两个有序的链表合并为一个有序链表。为了编程方便，在程序中引入dummy节点。具体程序如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *dummy = new ListNode(0);
        ListNode *head = nullptr, *start = dummy;
        int flag = true;
        while(l1 && l2)
        {
            if(l1->val < l2->val)
            {
                start->next = l1;
                l1 = l1->next;
            }
            else 
            {
                start->next = l2;
                l2 = l2->next;
            }
            start = start->next;
        }
        
        if(!l1)
            start->next = l2;
        else if(!l2)
            start->next = l1;
        
        head = dummy->next;
        delete dummy;
        dummy = nullptr;
        
        return head;
    }
};

　 2. 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* mergeKLists(vector<ListNode*>& lists) {
        int sz = lists.size();
        if(sz == 0)
            return nullptr;
        
        ListNode *node = new ListNode(0);
        ListNode *head = nullptr, *start = node;
        while(true)
        {
            int count = 0;
            int minVal = INT_MAX;
            int minNode = -1;
            for(int i = 0; i < sz; i++)
            {
                if(lists[i] && lists[i]->val < minVal)
                {
                    minNode = i;
                    minVal = lists[i]->val;
                }
                else if(!lists[i])
                    count++;
            }
            
            if(count != sz)
            {
                start->next = lists[minNode];
                lists[minNode] = lists[minNode]->next;
            }
            else
            {
                head = node->next;
                delete node;
                node = nullptr;
                
                return head;
            }
            
            start = start->next;
        }
    }
};

　　后来参考网上的做法，用Divide and Conquer方法会比较好，具体程序如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *node = new ListNode(0);
        ListNode *head = nullptr, *start = node;
        int flag = true;
        while(l1 && l2)
        {
            if(l1->val < l2->val)
            {
                start->next = l1;
                l1 = l1->next;
            }
            else 
            {
                start->next = l2;
                l2 = l2->next;
            }
            start = start->next;
        }
        
        if(!l1)
            start->next = l2;
        else if(!l2)
            start->next = l1;
        
        head = node->next;
        delete node;
        node = nullptr;
        
        return head;
    }

    ListNode *mergeKLists(vector<ListNode*>& lists, int low, int high)
    {
        if(low < high)
        {
            int mid = (low + high) / 2;
            return mergeTwoLists(mergeKLists(lists, low, mid), mergeKLists(lists, mid + 1, high));
        }
        return lists[low];
    }
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int sz = lists.size();
        if(sz == 0)
            return nullptr;
        
        return mergeKLists(lists, 0, sz - 1);
    }
};

 　　算法分析摘自同一博文：

　　我们来分析一下上述算法的时间复杂度。假设总共有k个list，每个list的最大长度是n，那么运行时间满足递推式T(k) = 2T(k/2)+O(n*k)。根据主定理，可以算出算法的总复杂度是O(nklogk)。如果不了解主定理的朋友，可以参见主定理-维基百科。空间复杂度的话是递归栈的大小O(logk)。