leetcode 23. Merge k Sorted Lists

最新推荐文章于 2024-02-04 15:23:14 发布

琥珀彩

最新推荐文章于 2024-02-04 15:23:14 发布

阅读量332

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/ac540101928/article/details/51543973

版权

leetcode 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

题目：

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

合并k个排好序的的链，并且返回一个有序链。

方法一：

想到21题是合并两个排好序的链，那么这个题可以借鉴思想。

每次从数组中取两个链表，将合并结果加入到链表中，反复这个过程，直到数组中只剩一个链表为止,对两个链表进行合并的代码可以复用LeetCode21的代码。

/**
 * 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) 
    {
        //lists的长度
        int length = lists.size();
        if(length==0)
        return NULL;

        while(lists.size()>1)
        {
            ListNode *p,*q;
            
            p=lists.front();
            lists.erase(lists.begin());
            q=lists.front();
            lists.erase(lists.begin());          
            lists.push_back(merge2Lists(p,q));
        }     
        return lists[0];
    }
    
    
    //根据leetcode 21题的，合并两个排好序的链的方法思路合并
    ListNode * merge2Lists(ListNode * p , ListNode * q)
    {
        if(p==NULL)
        return q;
        if(q==NULL)
        return p;
        
        ListNode *t1,*t2,*head,*tail;
        
        t1=p;
        t2=q;
        if(p->val < q->val)
        {
            head=p;
            t1=t1->next;
            tail=p;
        }
        else
        {
            head=q;
            t2=t2->next;
            tail=q;
        }
        
        while(t1!=NULL && t2!=NULL)
        {
            if(t1->val<t2->val)
            {
                tail->next=t1;
                t1=t1->next;
            }
            else
            {
                tail->next=t2;
                t2=t2->next;
            }
            tail=tail->next;
        }
        
        if(t1==NULL)
            tail->next=t2;
        else
            tail->next=t1;
        
        return head;
    }
};                                                                                                                                   // 创建链表
ListNode* CreateList(int A[],int n)
{
    ListNode *head = NULL;
    if(n <= 0){
        return head;
    }
    head = new ListNode(A[0]);
    ListNode *p1 = head;
    for(int i = 1;i < n;i++){
        ListNode *node = new ListNode(A[i]);
        p1->next = node;
        p1 = node;
    }
    return head;
}

int main() 
{
    Solution solution;
    vector<ListNode *> vecs;
    int A[] = {1,2,4,7,9};
    int B[] = {3,5,8,10,11,12};
    int C[] = {6,10,13};
    int D[] = {15,16,17,23};
    ListNode* head1 = CreateList(A,5);
    ListNode* head2 = CreateList(B,6);
    ListNode* head3 = CreateList(C,3);
    ListNode* head4 = CreateList(D,4);

    vecs.push_back(head1);
    vecs.push_back(head2);
    vecs.push_back(head3);
    vecs.push_back(head4);

    ListNode *head = solution.mergeKLists(vecs);
    // 输出
    ListNode *p = head;
    while(p){
        cout<<p->val<<" ";
        p = p->next;
    }
}<span style="white-space:pre">	</span>

方法二：

利用堆排序的思想。

参考他的博客：http://www.cnblogs.com/skysand/p/4300711.html