[LeetCode]C语言-Merge k Sorted Lists-程序优化之路

最新推荐文章于 2021-01-24 23:42:59 发布
最新推荐文章于 2021-01-24 23:42:59 发布
阅读量503 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode C 优化 算法 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37957508/article/details/80376562
版权

这道题要求将k个已排序的链表合并，刚开始看到这个题，首先想到是它上一个题将两个有序链表合并（主要通过一个while循环判断两个链表元素值中哪个大，然后就链接那个链表元素），我接着想直接定义一个链表让它与每一个链表通过调用函数合并，最后就能得到结果。

224ms

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* head = NULL;
    struct ListNode* ans = NULL;
    
    if(l1 == NULL && l2 == NULL) {
        return ans;
    }
    else if(l1 != NULL && l2 == NULL) {
        return l1;
    }
    else if(l2 != NULL && l1 == NULL) {
        return l2;
    }

    if(l1->val <= l2->val) {
        head = l1;
        l1 = l1->next;
    }
    else {
        head = l2;
        l2 = l2->next;
    }
    
    ans = head;
    
    while(l1 != NULL && l2 != NULL) {
        if(l1->val <= l2->val) {
            head->next = l1;
            head = head->next;
            l1 = l1->next;
        }
        else {
            head->next = l2;
            head = head->next;
            l2 = l2->next;
        }
    }
    while(l1 != NULL){
        head->next = l1;
        head = head->next;
        l1 = l1->next;
    }
    while(l2 != NULL){
        head->next = l2;
        head = head->next;
        l2 = l2->next;
    }
    return ans;
}
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    struct ListNode* ans = NULL;
    int i = 0;

    if(listsSize == 0) {
        return NULL;
    }
    else if(listsSize == 1) {
        return lists[0];
    }
    else {
        ans = mergeTwoLists(lists[0], lists[1]);
    }
    for(i=2; i<listsSize; i++) {
        ans = mergeTwoLists(ans, lists[i]);
    }
    return ans;
}

直接运行通过，还是很高兴，但是看到运行时间居然是两百多毫秒，这让我这个强迫症患者如何能接受得了，我就开始优化代码。首先肯定找执行次数最多的地方—for循环里面的语句，每次循环就调用mergeTwoLists函数，接着我想或许这个函数有问题，通过一段时间仔细查看，终于发现冗余的地方，那就是函数末尾两个while循环，它本来处理当其中一个链表结束，另一个剩余链表元素。但是这项工作只需运行一次就能实现，而无需重复多次运行，最后我将while改成if，果然大大减少了运行时间。

124ms

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* head = NULL;
    struct ListNode* ans = NULL;
    
    if(l1 == NULL && l2 == NULL) {
        return ans;
    }
    else if(l1 != NULL && l2 == NULL) {
        return l1;
    }
    else if(l2 != NULL && l1 == NULL) {
        return l2;
    }

    if(l1->val <= l2->val) {
        head = l1;
        l1 = l1->next;
    }
    else {
        head = l2;
        l2 = l2->next;
    }
    
    ans = head;
    
    while(l1 != NULL && l2 != NULL) {
        if(l1->val <= l2->val) {
            head->next = l1;
            head = head->next;
            l1 = l1->next;
        }
        else {
            head->next = l2;
            head = head->next;
            l2 = l2->next;
        }
    }
    if(l1 != NULL) {
        head->next = l1;
    }
    if(l2 != NULL) {
        head->next = l2;
    }
    return ans;
}

虽然已经减少一半了，但是还没到最好的8ms,对于我这个强迫症患者还是不舒服斯基，于是我继续代码优化，首先我认为mergeTwoLists函数已经没法优化了，那就只能优化主函数，当我实在没办法的时候，我看了一下leetcode后面解决思路，一下子明白问题出在哪，我这个程序以ans链表为主，使其不断与其它链表合并，带来的后果是ans链表越来越长，for循环越到后面，mergeTwoLists函数会花费越来越多时间。而替换方案是，每两个链表合并，得到一组新链表，然后再次两两合并，这样循环下去。两种方案虽然mergeTwoLists函数调用次数无太大区别，但是前一种每次循环就增加时间，而第二种是每次所有链表两两合并后增加时间，比前一种减少了大量累加时间。

8ms

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* head = NULL;
    struct ListNode* ans = NULL;
    
    if(l1 == NULL && l2 == NULL) {
        return ans;
    }
    else if(l1 != NULL && l2 == NULL) {
        return l1;
    }
    else if(l2 != NULL && l1 == NULL) {
        return l2;
    }

    if(l1->val <= l2->val) {
        head = l1;
        l1 = l1->next;
    }
    else {
        head = l2;
        l2 = l2->next;
    }
    
    ans = head;
    
    while(l1 != NULL && l2 != NULL) {
        if(l1->val <= l2->val) {
            head->next = l1;
            head = head->next;
            l1 = l1->next;
        }
        else {
            head->next = l2;
            head = head->next;
            l2 = l2->next;
        }
    }
    if(l1 != NULL) {
        head->next = l1;
    }
    if(l2 != NULL) {
        head->next = l2;
    }
    return ans;
}
struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {
    struct ListNode* ans = NULL;
    int i = 0;
    
    if(listsSize == 0) {
        return NULL;
    }
    else if(listsSize == 1) {
        return lists[0];
    }
    else {
        while(listsSize > 1) {
            for(i=0; i<listsSize/2; i++) {
                lists[i] = mergeTwoLists(lists[listsSize-i-1], lists[i]);
            }
            if(listsSize % 2 != 0) {
                lists[i-1] = mergeTwoLists(lists[i-1], lists[i]);
            }
            listsSize = listsSize / 2;
        }
        ans = lists[0];
    }
    
    return ans;
    
}


m0_37957508
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode23~Merge k Sorted Lists Add to List
stone_yw的博客
02-28 959
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 把k个有序的链表合并成一个新的有序链表 1 使用分治思想，借鉴于归并排序。数组的数递归划分，一分二，二分四…直至最后一个数单独的成为一组，然后再进行归并划分采用的递归实现，归并可以使用上题的方法。时间
LeetCode Merge 2 Sorted Lists解决方案
01-23
LeetCode Merge 2 Sorted Lists解决方案详解 Merge 2 Sorted Lists是LeetCode上的一个经典算法题目，旨在考察程序员对链表的操作和排序算法的掌握程度。下面对该题目的解决方案进行详细的分析和解释。 问题描述 ...
leetcode 21.合并两个有序链表
weixin_40421645的博客
09-11 131
合并两个有序链表 本人大四实习生，水平有限。有错望海涵。 思路 可使用递归。比较两个链表的头结点，值小的当头结点 代码 /** * Definition for singly-linked list. * public class ListNode { * public int val; * public ListNode next; * ...
算法:Merge k Sorted Lists(合并 k 个排序链表)
AI架构师易筋
02-25 685
说明 算法：Merge k Sorted Lists LeetCode地址：https://leetcode.com/problems/merge-k-sorted-lists/ 题目： Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Example...
leetcode 23. Merge k Sorted Lists 几种解法
柳汀轩
05-03 509
1.取值排序法 首先我们最先想到的可能是将所有链表的值放进一个数组中，然后进行排序，最后将排序后的元素依次构建新的链表。代码如下： class Solution(object): def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNo...
【LeetCode】23. Merge k Sorted Lists 合并K个升序链表
负雪明烛
10-16 4947
作者： 负雪明烛 id： fuxuemingzhu 个人博客： http://fuxuemingzhu.cn/ 题目地址: https://leetcode.com/problems/merge-k-sorted-lists/description/ 题目描述： Merge k sorted linked lists and return it as one sorted list. ...
c语言-c语言编程基础之leetcode题解第23题合并K个升序链表.zip
最新发布
04-19
本题来自著名的在线编程挑战平台LeetCode，题号为第23题，名为“Merge K Sorted Lists”（合并K个升序链表）。这是一道典型的数据结构与算法题目，主要考察的是链表操作和排序技巧。 链表是计算机科学中常用的一种...
leetcode跳跃-leetcode:leetcode解题之路
06-30
leetcode 跳跃 leetcode 按题型标签，记录...合并K个排序链表](./Heap/merge-k-sorted-lists.md) String 字符串 [0006 Z字形变换](./String/zigzag-conversion.md) [0030 串联所有单词的子串](./String/substring
leetcode2-Leetcode:Leetcode_answer
06-29
leetcode 2 Leetcode答案集 关于项目： 本项目包含本人LeetCode解题的答案，全部将由JavaScript语言进行解答。并会在每个题目的文件夹中添加相关的思路解析。 详情 # Title Solution Time Space Difficulty 1 Two ...
leetcode答案-LeetCode-Trip:LeetCode刷题代码，大佬勿入
06-30
leetcode 答案 LeetCode-Trip LeetCode刷题代码，大佬勿入。 为一年后的研究生找工作准备 目标是BAT的算法岗哈哈哈哈哈 争取做到每日一更 嗯…… 19.10.22：鸽了这么久，我又回来了……主要在实验室天天没啥事，过于...
leetcode -- Merge k Sorted Lists -- 重点有trick
xyqzki的专栏
12-11 970
https://leetcode.com/problems/merge-k-sorted-lists/思路就是把所有的head节点入heap，然后把root，heappop出来。再把被pop出来的node所属于的list的下一个node入heap. 知道heap为空这里要用到heap，python中有heapq.heapify([])这个函数可以对heap进行create，从而进行操作。以及 hea
23. Merge k Sorted Lists
weixin_49991368的博客
01-24 138
题目： You are given an array ofklinked-listslists, each linked-list is sorted in ascending order. Merge all the linked-lists into one sorted linked-list and return it. Example 1: Input: lists = [[1,4,5],[1,3,4],[2,6]] Output: [1,1,2,3,4,4,5,6] Exp...
【LeetCode】23. Merge k Sorted Lists 解题报告（Python）
L141210113的专栏
03-02 515
题目分析： 这一题是把n个有序链表合成一条有序链表。 1、可以先创建一条新链表，再把n个有序链表的head放入字典，然后选出最小值，把最小的值加入新链表。 2、然后把最小值从字典中删除，同时也把那个节点从小链表中删除，并把下一个节点值加入字典。 3、循环1、2知道字典为空。 代码说明： 1、给字典赋初值（每个链表的第一个元素） for i in range(len(lists)): ...
LeetCode 21. Merge Two Sorted Lists(合并两个有序链表) -- c语言
d_benhua的博客
05-24 234
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. Example: Input: 1->2-&gt...
Merge k sorted list--LeetCode
鱼思故渊的专栏
03-24 952
题目： Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 思路： 对于合并K个排好序的链表，最好的方法就是使用一个K个元素的最小堆，每次选择堆顶元素作为新的元素，等到K个元素均为空，说明所有的插入都已经结束。 不过这里也可以使用K个
[4.3]STL容器List之内部Sort算法原理
生命的2.0
10-02 504
引言：list没有使用STL的通用Sort算法，而是实现了自己的内部排序算法.这个算法使很多人Confused。本文是关于list内部sort算法的改进，如果这个Sort写成下面这样，相信很多人不会再Confuse. 算法原理： 引言：这个算法使很多人Confused。下面是我的改进，如果写成下面这样，相信很多人不会再Confuse. 算法流程： 1、定义一个临时list变量carry，一个缓存排序结果的变量result 2、将待排序的list的begin处的节点接合(sp
Merge k Sorted Lists
ncst
11-26 192
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Have you met this question in a real interview?  Yes Example Given lists: [ 2
leetcode oj java 23. Merge k Sorted Lists
Xcy的博客
12-28 244
一、问题描述： Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Subscribe to see which companies asked this question 二、解决思路： Merge k Sorted Lis
【Leetcode】Merge K Sorted Linked List
ljffdream的专栏
07-16 334
【题目】 Merge k sorted Linked Lists and return it as one sorted lists. Analyze and describe its complexity . 【思路】 leetcode clean book 【代码】 private static final Comparator listComparator = new
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值