leetcode merge-k-sorted-lists

最新推荐文章于 2020-01-21 08:56:03 发布
最新推荐文章于 2020-01-21 08:56:03 发布
阅读量88 收藏
点赞数
分类专栏： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pynash123/article/details/86544236
版权

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

方法1 借助堆

bool cmp (ListNode * l1, ListNode *l2)
{
    return l1->val > l2->val;
}

//借助堆， 每次new
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        //vector<ListNode *> vec(lists.begin(), lists.end());//这样子不对，有可能lists里面有空指针
        vector<ListNode *> vec;
        for (int i=0;i<lists.size();i++)
        {
            if (NULL != lists[i])
                vec.push_back(lists[i]);
        }
        ListNode * head = new ListNode (-1);
        ListNode * pre = head;
        make_heap(vec.begin(), vec.end(), cmp);
        while(!vec.empty())
        {
            ListNode * tmp = vec[0];
            pop_heap(vec.begin(), vec.end(),cmp);
            vec.pop_back();
            pre->next = new ListNode (tmp->val);
            pre = pre->next;
            if (NULL != tmp->next)
            {
                vec.push_back(tmp->next);
                push_heap(vec.begin(), vec.end(),cmp);
            }
        }
        return head->next;
    }
};


//借助堆 不new
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        vector<ListNode *> vec;
        for (int i=0;i<lists.size();i++)
        {
            if (NULL != lists[i])
                vec.push_back(lists[i]);
        }
        ListNode * head = new ListNode (-1);
        ListNode * pre = head;
        make_heap(vec.begin(), vec.end(), cmp);
        while(!vec.empty())
        {
            ListNode * tmp = vec[0];
            ListNode * tmpnext = tmp->next;
            pop_heap(vec.begin(), vec.end(),cmp);
            vec.pop_back();
            pre->next = tmp;
            pre = pre->next;
            if (NULL != tmpnext)
            {
                vec.push_back(tmpnext);
                push_heap(vec.begin(), vec.end(),cmp);
            }
        }
        return head->next;
    }
};

//两两合并
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        if (lists.size() == 0)
            return NULL;
        while (lists.size()>1)
        {
            vector<ListNode *> vec;
            for (int i=0; i<lists.size(); i++)
            {
                if(i%2 == 1)
                    vec.push_back(mergeTwoLists(lists[i-1], lists[i]));
            }
            if (lists.size()%2 == 1)
                vec.push_back(*(lists.end()-1));
            lists.swap(vec);
        }
        return lists[0];
    }
    
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) 
    {
        if(l1 == NULL)
        return l2;
        if(l2 == NULL)
            return l1;
        ListNode * tmp1 = l1;
        ListNode * tmp2 = l2;
        ListNode * Head = new ListNode(0);
        ListNode * tmp1_pre = Head;

        Head->next = l1;
        while(tmp2 != NULL&&tmp1 != NULL)
        {
            if (tmp2->val > tmp1->val)
            {
                tmp1_pre = tmp1;
                tmp1 = tmp1->next;
            }
            else
            {
                ListNode * tmp = tmp2->next;
                tmp1_pre->next = tmp2;
                tmp2->next = tmp1;
                tmp2 = tmp;
                tmp1_pre = tmp1_pre->next;
            }
        }
        if (tmp1 == NULL)
        {
            tmp1_pre->next = tmp2;
        }
        return Head->next;
    }
};

方法2 借助之前的merge-2-sorted-lists 两两合并

//两两合并
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        if (lists.size() == 0)
            return NULL;
        while (lists.size()>1)
        {
            vector<ListNode *> vec;
            for (int i=0; i<lists.size(); i++)
            {
                if(i%2 == 1)
                    vec.push_back(mergeTwoLists(lists[i-1], lists[i]));
            }
            if (lists.size()%2 == 1)
                vec.push_back(*(lists.end()-1));
            lists.swap(vec);
        }
        return lists[0];
    }
    
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) 
    {
        if(l1 == NULL)
        return l2;
        if(l2 == NULL)
            return l1;
        ListNode * tmp1 = l1;
        ListNode * tmp2 = l2;
        ListNode * Head = new ListNode(0);
        ListNode * tmp1_pre = Head;

        Head->next = l1;
        while(tmp2 != NULL&&tmp1 != NULL)
        {
            if (tmp2->val > tmp1->val)
            {
                tmp1_pre = tmp1;
                tmp1 = tmp1->next;
            }
            else
            {
                ListNode * tmp = tmp2->next;
                tmp1_pre->next = tmp2;
                tmp2->next = tmp1;
                tmp2 = tmp;
                tmp1_pre = tmp1_pre->next;
            }
        }
        if (tmp1 == NULL)
        {
            tmp1_pre->next = tmp2;
        }
        return Head->next;
    }
};

测试

#include <iostream>
#include <algorithm>
#include <vector>
 
using namespace std;



struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

bool cmp (ListNode * l1, ListNode *l2)
{
    return l1->val > l2->val;
}
    
ListNode * generateLinkList(vector<int> vec)
{
    ListNode * head = NULL;
    if (vec.size() == 0)
        return head;
    head = new ListNode(vec[0]);
    ListNode * tmp = head;
    for (int i = 1; i<vec.size(); i++)
    {
        tmp->next = new ListNode(vec[i]);
        tmp = tmp->next;
    }
    return head;
}
void print(ListNode * head)
{
    while(head != NULL)
    {
        cout<<head->val<<" ";
        head = head->next;
    }
    cout<<endl;
}
 
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        vector<ListNode *> vec;
        for (int i=0;i<lists.size();i++)
        {
            if (NULL != lists[i])
                vec.push_back(lists[i]);
        }
        ListNode * head = new ListNode (-1);
        ListNode * pre = head;
        make_heap(vec.begin(), vec.end(), cmp);
        while(!vec.empty())
        {
            ListNode * tmp = vec[0];
            pop_heap(vec.begin(), vec.end(),cmp);
            vec.pop_back();
            pre->next = new ListNode (tmp->val);
            pre = pre->next;
            if (NULL != tmp->next)
            {
                vec.push_back(tmp->next);
                push_heap(vec.begin(), vec.end(),cmp);
            }
        }
        return head->next;
    }
};

class Solution1 {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        if (lists.size() == 0)
            return NULL;
        while (lists.size()>1)
        {
            vector<ListNode *> vec;
            for (int i=0; i<lists.size(); i++)
            {
                if(i%2 == 1)
                    vec.push_back(mergeTwoLists(lists[i-1], lists[i]));
            }
            if (lists.size()%2 == 1)
                vec.push_back(*(lists.end()-1));
            lists.swap(vec);
        }
        return lists[0];
    }
    
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) 
    {
        if(l1 == NULL)
        return l2;
        if(l2 == NULL)
            return l1;
        ListNode * tmp1 = l1;
        ListNode * tmp2 = l2;
        ListNode * Head = new ListNode(0);
        ListNode * tmp1_pre = Head;

        Head->next = l1;
        while(tmp2 != NULL&&tmp1 != NULL)
        {
            if (tmp2->val > tmp1->val)
            {
                tmp1_pre = tmp1;
                tmp1 = tmp1->next;
            }
            else
            {
                ListNode * tmp = tmp2->next;
                tmp1_pre->next = tmp2;
                tmp2->next = tmp1;
                tmp2 = tmp;
                tmp1_pre = tmp1_pre->next;
            }
        }
        if (tmp1 == NULL)
        {
            tmp1_pre->next = tmp2;
        }
        return Head->next;
    }
};

//借助堆 不new
class Solution3 {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) 
    {
        vector<ListNode *> vec;
        for (int i=0;i<lists.size();i++)
        {
            if (NULL != lists[i])
                vec.push_back(lists[i]);
        }
        ListNode * head = new ListNode (-1);
        ListNode * pre = head;
        make_heap(vec.begin(), vec.end(), cmp);
        while(!vec.empty())
        {
            ListNode * tmp = vec[0];
            ListNode * tmpnext = tmp->next;
            pop_heap(vec.begin(), vec.end(),cmp);
            vec.pop_back();
            pre->next = tmp;
            pre = pre->next;
            if (NULL != tmpnext)
            {
                vec.push_back(tmpnext);
                push_heap(vec.begin(), vec.end(),cmp);
            }
        }
        return head->next;
    }
};

int main()
{
    Solution s;
    int A[] = {-1,1,2,3,4,5,6};
    vector<int> vec(A, A +7);
    sort(vec.begin(), vec.end());
    ListNode * head1 = generateLinkList(vec);
    
    int B[] = {-5,-4, 7,8,9};
    vector<int> vec1(B, B +5);
    sort(vec1.begin(), vec1.end());
    ListNode * head2 = generateLinkList(vec1);
    
    int C[] = {-9,22,33};
    vector<int> vec2(C, C +3);
    sort(vec2.begin(), vec2.end());
    ListNode * head3 = generateLinkList(vec2);
    
    vector<ListNode *> veclist;
    veclist.push_back(head1);
    veclist.push_back(head2);
    veclist.push_back(head3);
    ListNode * head = s.mergeKLists(veclist);
    print(head);
}
pynash123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode Merge 2 Sorted Lists解决方案
01-23
LeetCode Merge 2 Sorted Lists解决方案
merge-k-sorted-lists[合并链表]
小白太白的博客
08-13 101
题目描述 Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 思路 按顺序合并所有的链表并返回头结点。 法一：优先队列存储所有的链表头结点，每次取最小值连接并使它的下一个加入到队列中。 法二：从第一个链表开始依次合并后再返回头结点。 //法一 /...
leetcode 之 Merge k Sorted Lists
姚光超的专栏
03-16 1804
问题来源：Merge k Sorted Lists 该问题是一个很经典的问题，给定k个有序链表将其合并成1个有序链表。很多人应该在实际的面试中遇到过该问题（至少我会经常问面试者该问题，因为接着可以问堆相关的算法~）。为啥要针对该经典问题写篇博客呢，是因为该问题确实会在日常工作中出现，但是却很少有人想到用优化的算法来解决该问题。我们先看一下该问题的两种优化解法。 解法一 最常用的方法是利用最小堆（链...
LeetCode 23. Merge k Sorted Lists 合并k个已排序的链表为一个排序链表
南方以北
09-04 899
Mergeksorted 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-...
Merge k Sorted Lists -- LeetCode
编程语言小筑
02-25 147
原题链接:http://oj.leetcode.com/problems/merge-k-sorted-lists/这道题目在分布式系统中非常常见，来自不同client的sorted list要在central server上面merge起来。这个题目一般有两种做法，下面一一介绍并且分析复杂度。 第一种做法比较容易想到，就是有点类似于MergeSort的思路,就是分治法，不了解MergeSort的...
LeetCode Merge k Sorted Lists 解题报告
算法的天空
10-11 9084
合并K个已排序的数组，并分析整个算法的复杂度。 最朴素的方法TLE，借鉴归并排序的算法顺利AC，算法时间复杂度：NlogK
leetcode2-Leetcode:Leetcode_answer
06-29
leetcode 2 Leetcode答案集 关于项目： 本项目包含本人LeetCode解题的答案，全部将由JavaScript语言进行解答。并会在每个题目的文件夹中添加相关的思路解析。...Merge Two Sorted Lists JavaScript O(n)
leetcode跳跃-leetcode:leetcode解题之路
06-30
leetcode 跳跃 leetcode 按题型标签，记录...合并K个排序链表](./Heap/merge-k-sorted-lists.md) String 字符串 [0006 Z字形变换](./String/zigzag-conversion.md) [0030 串联所有单词的子串](./String/substring
leetcode答案-LeetCode:Swift中的LeetCode
06-30
Merge Two Sorted Lists Easy #26 Remove Duplicates from Sorted Array Easy #27 Remove Element Easy #35 Search Insert Position Easy #38 Count and Say Easy #53 Maximum Subarray Easy #66 Plus One Easy #70 ...
leetcode答案-LeetCode-Trip:LeetCode刷题代码，大佬勿入
06-30
Merge Two Sorted Lists] [53. Maximum Subarray] [70. Climbing Stairs] [101. Symmetric Tree] [104. Maximum Depth of Binary Tree] [121. Best Time to Buy and Sell Stock] [167. Two Sum II - Input array is ...
leetcode23. Merge k Sorted Lists 多种解法总结
Schnee-Cy的博客
06-20 1781
23. Merge k Sorted ListsMerge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.Example:Input: [   1-&gt;4-&gt;5,   1-&gt;3-&gt;4,   2-&gt;6 ] Output: 1-&gt;1...
leetcode---merge-k-sorted-lists---链表
新博客：https://aping-dev.com/
10-25 266
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;
LeetCode—merge-k-sorted-lists（归并排序链表）—java
Lynn_Baby的博客
06-07 471
题目描述：Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.思路解析：归并排序是排列数组的，现在应用到排列list这里来复习一下Merge Sort(对于数组操作），参考Wikipedia：归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列...
leetCode(merge-k-sorted-lists)-合并k个排序链表
Wenlong_L的博客
05-14 199
题目：给定一个排序链表的集合，将其按照顺序排列成一个单链表，返回新的头指针。 思路： 和上一篇博客中的合并两个排序链表思路是一样的，循环从集合中取新的链表，将上次排好序的链表作为链表1，当前取得新的链表作为链表2，采取相同的方法进行merge，就可以了，在上一篇博客的基础上只是增加了一层外围循环。 ...
LeetCode--merge-k-sorted-lists
wl_ss的博客
01-01 417
题目描述 Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 合并k个排序链表 思路1: 使用优先队列(实质与堆相差无几)  priority_queue   struct co
Merge_k_Sorted_Lists
numbstorm的博客
12-29 163
题目描述：Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.(合并k个有序链表).思路:普通思路就是把每条链表单拿出来遍历，然后将链表中的元素一个一个往结果集中按大小放，直到所有链表都被遍历完。如果有n条链表，每个list的最大长度是m，假如使用，时间复...
23. Merge k Sorted Lists
caisense的专栏
06-01 170
https://leetcode.com/problems/merge-k-sorted-lists/description/ 题意：合并k（不定）个有序链表 思路1：设计了一个自认为非常巧的暴力法，思路和两个表合并差不多，每次遍历k个表找最小节点插入新链，找到的第i个链指针前移一位。直到所有链遍历完，还用了一个小技巧，当处理到只剩一条链时，直接加入新链。 让并卵，超时了，还不如soluti...
第二周Merge k Sorted Lists
tmhf_cc的博客
09-15 141
Merge k Sorted Lists 本周讲的是分治，所以选的题目也是分治的问题 LeetCode上的23题：https://leetcode.com/problems/merge-k-sorted-lists/description/ Merge k Sorted Lists 题目 题解 代码 分析 题目 Merge k sorted linked lists an...
lintcode merge-k-sorted-lists 三种方法解读
qq_40647378的博客
01-21 427
java的get和set 就是一般用于private 对于一个class 操作 变量 进行操作 第一种方法 每次在每个列表中选一个最小值 定一个初始值 一开始只放k个值，开好空间 ----Heapsort 在节点ListNode定义中，定义为节点为结构变量。 节点存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，当 next 为空指针时，这...
idea leetcode-edito乱码
最新发布
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值