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();
         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 == )
             return nullptr;

         ListNode *node = new ListNode();
         ListNode *head = nullptr, *start = node;
         while(true)
         {
             int count = ;
             int minVal = INT_MAX;
             int minNode = -;
             for(int i = ; 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();
         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) / ;
             return mergeTwoLists(mergeKLists(lists, low, mid), mergeKLists(lists, mid + , high));
         }
         return lists[low];
     }

     ListNode* mergeKLists(vector<ListNode*>& lists) {
         int sz = lists.size();
         if(sz == )
             return nullptr;

         return mergeKLists(lists, , sz - );
     }
 };

　　算法分析摘自同一博文：

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