[c++]合并排序多个已排好序的单项链表

题目来源：Leetcode

题目描述：

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

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

---

思路：不断合并两个链直到所有合并完成O(kN) 

/**
 * 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* r=NULL;
        if(lists.size()==0) return r;
        for(int i=0;i<lists.size();++i)
        {
            r=mergeTwo(r,lists[i]);
        }
        return r;
    }
    ListNode* mergeTwo(ListNode *r1,ListNode *r2)
    {
        if(r1==NULL) return r2;
        if(r2==NULL) return r1;
        if(r1->val<=r2->val) { r1->next=mergeTwo(r1->next,r2); return r1;}
        else { r2->next=mergeTwo(r1,r2->next); return r2;}
    }
};

---

附加思路：将所有链表不断切半到只剩下两个，将其合并，回到上一层，将其合并

---

附加思路：先遍历所有链表把他们的值放入一个数组，放的时候就排序好的放，然后把链表连起来成一个链表，把数组的值依次赋值

Time complexity : O(Nlog N)O(NlogN) where NN is the total number of nodes.

• Collecting all the values costs O(N)O(N) time.
• A stable sorting algorithm costs O(Nlog N)O(NlogN) time.
• Iterating for creating the linked list costs O(N)O(N) time.

/**
 * 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* r=NULL;
        if(lists.size()==0) return r;
        vector<int> m;
        for(int i=0;i<lists.size();++i)
        {
            ListNode* t=lists[i];
            while(t!=NULL)
                {m.push_back(t->val);t=t->next;}
        }
        QuickSort(m,0,m.size()-1);
        r=lists[0];
        int j=0;
        for(int i=0;i<lists.size();++i)
        {
            ListNode* t=lists[i];
            while(t->next!=NULL)
            {
                t->val=m[j];
                ++j;
            }
            t->val=m[j];
            if(i+1<lists.size()) t->next=lists[i+1];
        }
        return r;
    }
    void QuickSort(vector<int>& list,int p,int r)//快排
    {
        
        if(p<r)  {
        int q=Part(list,p,r);
        QuickSort(list,p,q-1);
        QuickSort(list,q,r);
        }
    }
    int Part(vector<int>& list,int p,int r)
    {
        int i=p,j=r+1;
        int x=list[p];
        while(1)
        {
            while(list[++i]<x&&i<r);
            while(list[--j]>x);
            if(i>=j) break;
            int temp=list[i];
            list[i]=list[j];
            list[j]=temp;
        }
        list[p]=list[j];
        list[j]=x;
        return j;
    }
};

Run Code Status: 

Runtime Error