leetcode023：Merge k Sorted Lists

最新推荐文章于 2019-09-05 23:54:47 发布
最新推荐文章于 2019-09-05 23:54:47 发布
阅读量427 收藏
点赞数
分类专栏： Online Judge 文章标签： sort c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/barry283049/article/details/45060075
版权

问题描述

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

问题分析

思路1

这个问题是leetcode021合并两个有序列表的增强版：合并ｋ个有序列表。
实现原理比较相似：每次取ｋ个列表表头结点，依次找出这些头结点最小的（排序，便于后续利用），然后取最小结点所在列表的下一结点。这次学习了如何利用sort()函数给vector的非基本类型ListNode排序。

  • 先写比较函数
bool cmp_by_ListNode(const ListNode *left, const ListNode *right){
     return left->val < right->val;
}
  • 调用sort()排序函数
sort(vecList.begin(), vecList.end(), cmp_by_ListNode);
  • 代码

待优化

bool cmp_by_ListNode(const ListNode *left, const ListNode *right){
     return left->val < right->val;
}

 class Solution {
 public:
     ListNode *mergeKLists(vector<ListNode *> &lists) {
         int size = lists.size();
         // ListNode *ans_final = NULL;
         ListNode *ans = NULL;
         ListNode *ans_p = NULL;
         vector<ListNode *> vecList;
         for (int i = 0; i < size; i++){
             if (lists[i]) { vecList.push_back(lists[i]); }
         }
         size = vecList.size();
         if (!size) return NULL;
         if (size == 1) return *(vecList.begin());
         sort(vecList.begin(), vecList.end(), cmp_by_ListNode);
         vector<ListNode *>::iterator it;
         ListNode *k = NULL;    //k结点的值来自于上次vecList表头值（即最小值所在结点）
         int val;
         int flag;              //0：表示k结点的值比vecList中任何结点值都小，此时直接将k结点加入ans列表中，并让k后续指向k->next
         while (vecList.size() > 1 || vecList.size() == 1 && k){
             it = vecList.begin();
             val = (*it)->val;
             flag = 1;
             if (k){
                 if (k->val <= val){
                     val = k->val;
                     flag = 0;
                 }
                 else{
                     //方案1，加入vecList再排序,复杂度O(n*logn),n为vecList结点数目,运行时间154 ms
                     /*vecList.push_back(k);
                     sort(vecList.begin(), vecList.end(), cmp_by_ListNode);*/
                     //因为vecList本身是有序的，所以无需排序，只要将k值插入合适位置即可使得vecList有序（减少计算量）
                     //方案2，直接插入，查找复杂度为O(n)，插入复杂度也是O(n)[因为是连续内存，后面的元素需要腾出空间]，运行时间65 ms
                     /*vector<ListNode *>::iterator loc;
                     for (loc = vecList.begin(); loc != vecList.end(); loc++){
                     if ((*loc)->val > k->val) break;
                     }
                     if (loc != vecList.end()){
                         vecList.insert(loc, k);
                     }
                     else{
                         vecList.push_back(k);
                     }*/
                     //方案2改进：使用二分法查找，运行时间：60 ms
                     int l = 0, r = vecList.size() - 1;
                     int mid =( l + r) / 2;
                     while (l<r){
                         if (k->val < vecList[mid]->val)
                             r = mid;
                         else
                             l = mid;
                         mid = (l + r) / 2;
                         if (mid == l) break;
                     }vector<ListNode *>::iterator loc;
                     if (k->val >= vecList[r]->val) vecList.push_back(k);
                     else if (r - l == 1 && k->val > vecList[l]->val){
                         loc = vecList.begin() + r;
                         vecList.insert(loc, k);
                     }
                     else{
                         loc = vecList.begin() + l;
                         vecList.insert(loc, k);
                     }
                 }
             }
             ListNode *node = new ListNode(val);
             if (!ans) ans_p = ans = node;
             else {
                 ans_p->next = node; ans_p = node;
             }
             if (flag){
                 k = (*it)->next;
                 vecList.erase(it);
             }
             else k = k->next;
         }
         //if (vecList.size() == 1 && (!k)){
             if (!ans) ans = *vecList.begin();
             else ans_p->next = *vecList.begin();
        // }
         return ans;
     }
 };
  • 优化后的代码
    上述思路每次取最小的思想归结为用最小堆，其建堆算法复杂度为O(n)，且代码简化。基本和上述代码性能相当。
//运行时间：61 ms
bool cmp_by_ListNode(const ListNode *left, const ListNode *right){
     return left->val > right->val;
}
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int size = lists.size();
        // ListNode *ans_final = NULL;
        ListNode *ans = NULL;
        ListNode *ans_p = NULL;
        vector<ListNode *> vecList;
        for (int i = 0; i < size; i++){
            if (lists[i]) { vecList.push_back(lists[i]); }
        }
        size = vecList.size();
        if (!size) return NULL;
        if (size == 1) return vecList[0];
        make_heap(vecList.begin(), vecList.end(), cmp_by_ListNode);
        ListNode *k = NULL; //k结点的值来自于上次vecList表头值（即最小值所在结点）
        int val;
        int flag;               //0：表示k结点的值比vecList中任何结点值都小，此时直接将k结点加入ans列表中，并让k后续指向k->next
        while (vecList.size() > 1 || vecList.size() == 1 && k){
            val = vecList.front()->val;
            flag = 1;
            if (k){
                if (k->val <= val){
                    val = k->val;
                    flag = 0;
                 }
                     else{
                         vecList.push_back(k);
                         push_heap(vecList.begin(), vecList.end(), cmp_by_ListNode);
                     }
                 }
                 ListNode *node = new ListNode(val);
                 if (!ans) ans_p = ans = node;
                 else {
                     ans_p->next = node; ans_p = node;
                 }
                 if (flag){
                     k = vecList.front()->next;
                     pop_heap(vecList.begin(), vecList.end(), cmp_by_ListNode);
                     vecList.pop_back();
                 }
                 else k = k->next;
             }
             //if (vecList.size() == 1 && (!k)){
                 if (!ans) ans = *vecList.begin();
                 else ans_p->next = *vecList.begin();
            // }
             return ans;
    }
};

思路2

直接把k个列表放一个列表里，然后快排或建最小堆，复杂度O(nlogn)
- 快排代码

//运行时间：43ms
bool cmp_by_ListNode(const ListNode *left, const ListNode *right){
     return left->val < right->val;
}
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int size = lists.size();
        ListNode *ans = NULL;
        ListNode *ans_p = NULL;
        vector<ListNode *> vecList;
        for (int i = 0; i < size; i++){
            if (lists[i]) { vecList.push_back(lists[i]); }
        }
        size = vecList.size();
        if (!size) return NULL;
        if (size == 1) return vecList.front();
        int i = 0;
        while (i<size)
        {
            ListNode*p = vecList[i++];
            while (p->next){
                vecList.push_back(p->next);
                p = p->next;
            }
        }
        sort(vecList.begin(), vecList.end(), cmp_by_ListNode);
        size = vecList.size();
        i = 0;
        while (i<size){
            ListNode * node = new ListNode(vecList[i]->val);
            if (!ans) ans_p = ans = node;
            else { ans_p->next = node; ans_p = node; }
            i++;
        }
        return ans;
    }
};
  • 最小堆代码
    注：建立最小堆的比较函数是>，最大堆为<，STL默认建立最大堆。
//运行时间：52ms
bool cmp_by_ListNode(const ListNode *left, const ListNode *right){
     return left->val > right->val;
}
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int size = lists.size();
        // ListNode *ans_final = NULL;
        ListNode *ans = NULL;
        ListNode *ans_p = NULL;
        vector<ListNode *> vecList;
        for (int i = 0; i < size; i++){
            if (lists[i]) { vecList.push_back(lists[i]); }
        }
        size = vecList.size();
        if (!size) return NULL;
        if (size == 1) return vecList[0];
        int i = 0;
        while (i<size)
        {
            ListNode*p = vecList[i++];
            while (p->next){
                vecList.push_back(p->next);
                p = p->next;
            }
        }
        make_heap(vecList.begin(), vecList.end(), cmp_by_ListNode);
        while (!vecList.empty()){
            if (!ans) ans_p = ans = vecList.front();
            else{ ans_p->next = vecList.front(); ans_p = vecList.front(); }
            pop_heap(vecList.begin(), vecList.end(), cmp_by_ListNode);
            vecList.pop_back();
        }
        if (ans_p) ans_p->next = NULL;
        // }
        return ans;
    }
};
埋头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode Merge 2 Sorted Lists解决方案
01-23
LeetCode Merge 2 Sorted Lists解决方案
LeetCode 21：Merge Two Sorted Lists
哈哈的个人专栏
05-27 4527
LeetCode 21: 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. 题目分析：对两个
LeetCode 23： Merge K Sorted Lists
哈哈的个人专栏
05-31 4139
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 本题在上一题(LeetCode 21: Merge Two Sorted Lists)基础上再加深了一步，链表个数从两个改为K个。 此题有如下几种解法： 1、最简单的方法莫过于每次
leetcode 23. Merge k Sorted Lists
bohu83的博客
09-05 174
一 题目 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-...
leetcode23~Merge k Sorted Lists Add to List
stone_yw的博客
02-28 942
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 把k个有序的链表合并成一个新的有序链表 1 使用分治思想，借鉴于归并排序。数组的数递归划分，一分二，二分四…直至最后一个数单独的成为一组，然后再进行归并划分采用的递归实现，归并可以使用上题的方法。时间
LeetCode:Merge k Sorted Lists
walker lee
04-16 3164
Merge k Sorted Lists Total Accepted: 82424 Total Submissions: 354076 Difficulty: Hard Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexit
leetcode中文版-LeetCode:力码
06-29
leetcode中文版 LeetCode/Cpp 本人刷题记录在此，包含题意理解与算法思路，包含在Cpp文件内部注释，后续会持续更新。 有不懂的可以联系ji648513181，同时也欢迎志同道合O的朋友一起合作更新。 已更新剑指Offer答案...
leetcode2-Leetcode:Leetcode_answer
06-29
leetcode 2 Leetcode答案集 关于项目： 本项目包含本人LeetCode解题的答案，全部将由JavaScript语言进行解答。并会在每个题目的文件夹中添加相关的思路解析。 详情 # Title Solution Time Space Difficulty 1 Two ...
leetcode分类-leetcode:leetcode问题的代码
06-29
leetcode 分类leetcode 问题分类 leetcode代码仓库，我的解题思路写在我的博客里： leetcode 代码库，我博客上的解题思路： mkdir 列表： 大批 #1:Two Sum #4:Median of Two Sorted Arrays 地图 #1:Two Sum #3:...
leetcode被墙-leetcode:leetcode笔记
06-30
easy:21.Merge_Two_Sorted_Lists return a or b 首先我是第一次见到这种写法，查看了官方文档，引用如下： The expression x and y first evaluates x; if x is false, its value is returned; otherwise, y is ev
关于Time Limit Exceeded可能的原因
热门推荐
devbarry的专栏
01-13 1万+
今天在做POJ上面的一道题目《M × N Puzzle》，Problem ID：2893，测试全部通过，就是提示超时，在网上找到原题源码对比发现逻辑上一模一样。。。然后最后的最后终于找到问题了，在这篇Why do I get a Time Limit Exceeded?文章中提到 In C++, do not use cin/cout - use scanf and printf instea
最近公共祖先（LCA）：离线&在线算法
devbarry的专栏
05-19 3459
Tarjan算法适用于离线批量处理多个查询请求。基本思想是以深度优先搜索的顺序访问这颗树，给这棵树的结点染色，一开始所有结点都是白色的，而当第一次经过某个结点的时候，将它染成灰色，而当第二次经过这个结点的时候——也就是离开这棵子树的时候，将它染成黑色。
最大值最小化问题
devbarry的专栏
01-15 3382
问题描述可参考最大值最小化问题，问题在刘汝佳老师的算法竞赛入门经典书上的p151页，核心算法是二分法猜最大值，猜对了继续小化，猜错了增大数字，初始左值为序列第一个元素值，右值为序列和。 下面是我的C++实现代码 #include using namespace std; #define N 1000000 int a[N]; int search_min(int n,int k) { i
回溯法解决素数环问题
devbarry的专栏
01-04 2764
#include #include using namespace std; #define N 100000 int isp[2 * N]; int a[N]; int visited[N]; int is_prime(int n) { int i; int flag = 0; for (i = 2; i <= (int)sqrt(n) + 1;i++) { if (n%i
hiho一下 第三十周 小Hi小Ho的惊天大作战：扫雷·一
devbarry的专栏
01-25 2091
时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 故事背景：密室、监视器与充满危机的广场 “我们还是循序渐进，先来考虑这样一个简单化问题：”小Hi思索片刻，道：“在一个大小为2*N的广场，其中第一行里的某一些格子里可能会有至多一个地雷，而第二行的格子里全都为数字，表示第一行中距离与这个格子不超过2的格子里总共有多少个地雷，即第二行的
KMP算法解决字符串匹配
devbarry的专栏
08-27 1422
该算法由D.E.Knuth ，J.H.Morris和 V.R.Pratt提出，用于解决字符串匹配问题。思想：设目标串(主串)为s，模式串为t ，并设i指针和j指针分别指示目标串和模式串中正待比较的字符，设i和j的初值均为0。若有s[i]=t[j]，则i和j分别加1。否则，i不变，j退回到j=next[j-1]的位置，再比较s[i]和t[j]，若相等，则i和j分别加1。否则，i不变，j再次退回到j=n
hiho一下 第二十八周 最小生成树三·堆优化的Prim算法
devbarry的专栏
01-19 1141
时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 回到两个星期之前，在成功的使用Kruscal算法解决了问题之后，小Ho产生了一个疑问，究竟这样的算法在稀疏图上比Prim优化之处在哪里呢？ 提示：没有无缘无故的优化！ 输入 每个测试点（输入文件）有且仅有一组测试数据。 在一组测试数据中： 第1行为2个整数N、M，表示小Hi拥
leetcode212：Word Search II
devbarry的专栏
05-21 1005
问题描述点此链接 Given a 2D board and a list of words from the dictionary, find all words in the board.Each word must be constructed from letters of sequentially adjacent cell, where “adjacent” cells are tho
范围最小值问题（Range Minimum Query，RMQ）
devbarry的专栏
05-19 948
问题描述给定一个n个元素的序列{A1，A2，……，An}，在要求的区间Query（L,R）内找到最小值：min{AL,AL+1,……,AR}。hiho16算法描述在这里介绍最常用的Tarjan的Sparse-Table算法，它的预处理时间复杂度为O(nlogn)，而查询时间只需要O(1)。令calc(i,j)表示从i开始的，长度为2j 的一段子序列的最小值，则使用循环的方式计算：calc[i][j]
leetcode 101:和你一起你轻松刷题(c++) pdf
最新发布
07-30
"leetcode 101:和你一起你轻松刷题(c )"是一本关于刷题的 pdf 电子书。LeetCode 是一个流行的在线编程平台，提供了许多编程问题和算法题供程序员练习和挑战。这本电子书的目的是通过提供答案和解题思路帮助读者更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值