leetcode 23. Merge k Sorted Lists

原创 2016年05月31日 11:01:03

题目:

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



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

leetcode23~Merge k Sorted Lists Add to List

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

【leetcode】23. Merge k Sorted Lists

合并多个已排序的单链表,多种实现方式

[leetcode] 23. Merge k Sorted Lists

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

leetcode_23_Merge k Sorted Lists

思路: 本来想模仿合并两个链表的方法,查找所有的lists链表一遍找出一个最小值,并将最小值链接到结果链表中,并将最小结点删除,将最小结点的next结点替代之,直至为null,将链表删去。 但是当l...

LeetCode_OJ【23】Merge k Sorted Lists

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

leetcode--23. Merge k Sorted Lists

leetcode

leetcode23---Merge k Sorted Lists

问题描述:有k个已经排好序的链表,将其合并为一个有序链表。代码:#include #include #include using namespace std;struct ListNode { ...

LeetCode 23 Merge k Sorted Lists

这是一道基本的归并排序问题,设定步长d初始为1,然后以指数增长归并向量元素 每次归并的思想就是将后一个链表的元素插入前一个链表,如果前一个链表为空,则前一个链表直接指向后一个链表 当d大于...

Leetcode-23.Merge k Sorted Lists

Problem Description: Merge k sorted linked lists and return it as one sorted list. Analyze and desc...

leetcode23. Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)