算法集锦（NO.2）链表

最新推荐文章于 2024-09-21 16:35:48 发布
最新推荐文章于 2024-09-21 16:35:48 发布
阅读量132 收藏
点赞数
分类专栏： 链表 文章标签： 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42368577/article/details/118417623
版权
本文介绍了链表操作的几种方法，包括删除倒数第N个节点和合并两个有序链表。同时，探讨了如何在O(nlogn)时间复杂度下对链表进行排序，利用分治策略实现排序。此外，还提到了合并K个升序链表的解决方案，如使用分治和优先队列的方法。这些算法展示了在链表操作中如何高效地进行数据处理和排序。
摘要由CSDN通过智能技术生成

算法集锦（NO.2）

链表

DAY2：加油！！！

删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？
示例 1：
在这里插入图片描述
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

方法一：
该题求解的是倒数第n个数字，那么可以想到用两个相同的链表（head），第一个链表遍历n次。然后和第二个链表再同步遍历，直到第一个链表为空时，第二个链表此时的节点正好为题目所要求的倒数第n个节点。因为此题为单向链表，所以没有前置指针，所以此引入第三个链表来存储第二个链表的前置节点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode node = new ListNode(0,head);
        //第一个链表用来进行n次遍历
        ListNode tempOne = node.next;
        //第二个链表用来定位删去节点
        ListNode tempTwo = node.next;
        //第三个链表用来定位被删节点的前置节点
        ListNode tempThree = node;
        while(n>0&&tempOne!=null){
            tempOne = tempOne.next;
            n--;
        }
        if(n>0){
            return node.next;
        }
        //同步遍历，知道tempOne为空，此时tempTwo和tempThree分别为被删节点和被删节点的前置节点
        while(tempOne!=null){
            tempOne = tempOne.next;
            tempTwo = tempTwo.next;
            tempThree = tempThree.next;
        }
        //进行指定节点的删除
        tempThree.next = tempTwo.next;
        return node.next;
    }
}

在这里插入图片描述
时间复杂度O（N），空间复杂度O（1）

方法二：
遍历链表，取出所有元素放置在一个list中，然后删除倒数第二个元素，创建新链表，用list中的值对新链表赋值。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        LinkedList <Integer> list =new LinkedList<>();
        ListNode node = new ListNode(0);
        ListNode temp = node;
        //遍历链表
        while(head!=null){
            list.add(head.val);
            head = head.next;
        }
        //移除倒数第n个元素
        list.remove(list.size()-n);
        int num=0;
        //重组新链表
        while(num<list.size()){
            ListNode tempNext = new ListNode(list.get(num));
            temp.next = tempNext;
            temp = temp.next;
            num++;
        }
        return node.next;
    }
}

在这里插入图片描述
时间复杂度O（N），空间复杂度O（1）

方法三：
使用栈去存储，也是遍历head，存入deque中，然后取出计数，当为n的时候跳过，使用尾插法

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        Deque<Integer>stack = new LinkedList<>();
        ListNode node = new ListNode(0);
        ListNode temp = node;
        //把head的节点值存入stack中
        while(head!=null){
            stack.push(head.val);
            head = head.next;
        }
        //用num来进行尾部计数
        int num=1;
        //遍历头插法
        while(!stack.isEmpty()){
            if(num==n){
                num++;
                stack.pop();
                continue;
            }
            if(node.next==null){
                ListNode tempNext = new ListNode(stack.pop());
                node.next = tempNext;
                temp = node.next;
            }else{
                ListNode tempNext = new ListNode(stack.pop());
                node.next = tempNext;
                tempNext.next = temp;
                temp = node.next;
            }
            num++;
        }
        return node.next;
    }
}

在这里插入图片描述
合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：

输入：l1 = [], l2 = []
输出：[]
示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

方法一：
进行递归。在这里插入图片描述

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null){
            return l2;
        }
        if(l2==null){
            return l1;
        }
        //因为从一次遍历可知，后续的递归值都为前一次的后续节点
        if(l1.val<l2.val){
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1,l2.next);
            return l2;
        }
    }
}

在这里插入图片描述
时间复杂度O（n），空间复杂度O（1）

方法二：
迭代
在这里插入图片描述

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode node =new ListNode(0);
        ListNode temp = node;
        while(l1!=null||l2!=null){
        //numOne和numTwo进行l1和l2节点值的存储
            int numOne = l1==null?Integer.MAX_VALUE:l1.val;
            int numTwo = l2==null?Integer.MAX_VALUE:l2.val;
            //进行值的嵌入
            if(numOne<numTwo){
                temp.next = new ListNode(numOne);
                temp = temp.next;
                l1 = l1.next;
            }else{
                temp.next = new ListNode(numTwo);
                temp = temp.next;
                l2 = l2.next;
            }
        }
        return node.next;
    }
}

在这里插入图片描述
时间复杂度O（N），空间复杂度O（1）

合并K个升序链表
给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：

输入：lists = []
输出：[]
示例 3：

输入：lists = [[]]
输出：[]

提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
方法一：
使用一个空置节点对lists里面的值进行两两排序。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode node = null;
        for(int i=0;i<lists.length;i++){
        //对其进行遍历，并且和node进行不断的两两合并
            node=mergesortKLists(node,lists[i]);
        }
        return node;
    }
    public ListNode mergesortKLists(ListNode temp,ListNode lists){
    //若两个中，其中一个为空，那么另一个就是解集
        if(temp==null||lists==null){
            return temp==null?lists:temp;
        }
        ListNode node = new ListNode(0);
        ListNode tempNew = node;
        while(temp!=null||lists!=null){
            int numOne = temp==null?Integer.MAX_VALUE:temp.val;
            int numTwo = lists==null?Integer.MAX_VALUE:lists.val;
            if(numOne<numTwo){
                tempNew.next=new ListNode(numOne);
                temp = temp.next;
                tempNew = tempNew.next;
            }else{
                tempNew.next=new ListNode(numTwo);
                lists = lists.next;
                tempNew = tempNew.next;
            }
        }
        return node.next;
    }
}

在这里插入图片描述
该方法的代码优化

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode node = new ListNode(0);
        ListNode temp = node;
        for(int i=0;i<lists.length;i++){
            mergesortKLists(temp,lists[i]);
        }
        return node.next;
    }
    //优化了方法，直接引入辅助节点进行交换来优化程序
    public void mergesortKLists(ListNode temp,ListNode lists){
        ListNode temp1=temp;
        while(lists!=null){
        //因为temp1的初始节点为0，所以当他的next为空，即他还未与任何一个不为空的lists进行合并
            if(temp1.next==null){
                temp1.next=lists;
                break;
                //当他下一节点的值大于lists的值的时候，进行节点互换
            }else if(temp1.next.val>lists.val){
            //引入辅助节点tempNext来保存lists的首值
                ListNode tempNext = lists;
                //这里需要先将lists的next节点进行保存，防止接下来在指针转换时发生子链表丢失的情况
                lists = lists.next;
                //将所要拼接的节点指向temp1的下一个比他值大的节点
                tempNext.next = temp1.next;
                //tmp1后移
                temp1.next =tempNext;
            }else{
                temp1 = temp1.next;
            }
        }
    }
}

在这里插入图片描述
方法二：
分治算法，分而治之。因为方法一是一个辅助链表一个一个的和链表数组中的链表进行合并，该方法时间比较复杂。所以引入分治算法，使得链表数组自身两两合并，减少不必要的时间。

class Solution {
//merge方法进行对列表的分治拆分
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists,0,lists.length-1);
    }
    //将lists拆分至1个listnode和1个listnode类似于二叉树的形式，从叶子节点的两个进行合并，然后层层解套，得出最终解
    public ListNode merge(ListNode[]lists,int pre,int end){
        if(pre==end){
            return lists[pre];
        }
        if(pre>end){
            return null;
        }
        //找到中间平均值，进行两两拆分
        int mid = (pre+end)>>1;
        //当pre和end为相邻时，此时我们需要将后面的mid+1，因为>>1是向下取整，此时mid=pre。
        return mergesortKLists(merge(lists,pre,mid),merge(lists,mid+1,end));
    }
    //此为前几题相同的两个链表合并，此时需要注意的是，要保持原lists列表不遭到破坏，所以得新取listnode进行替代
    public ListNode mergesortKLists(ListNode pre,ListNode end){
        if(pre==null||end==null){
            return pre==null?end:pre;
        }
        ListNode node=new ListNode(0);
        ListNode temp1 = node;
        ListNode tempPre =pre;
        ListNode tempEnd = end;
        while(tempPre!=null&&tempEnd!=null){
            if(tempPre.val<tempEnd.val){
                temp1.next=tempPre;
                tempPre=tempPre.next;
                temp1=temp1.next;
            }else{
                temp1.next=tempEnd;
                tempEnd=tempEnd.next;
                temp1 = temp1.next;
            }
        }
        temp1.next = (tempPre!=null?tempPre:tempEnd);
        return node.next;
    }
}

在这里插入图片描述

在这里插入图片描述
方法三：
对优先队列进行改造，通过对其头节点的值进行排序，来得出最优解。每次取完头节点后，再将其节点向后移动并重新插入优先队列中。

class Solution {
//简历一个staus的class，里面存在节点值，和当前节点。
    class Status implements Comparable<Status> {
        int val;
        ListNode ptr;
//其构造函数赋值
        Status(int val, ListNode ptr) {
            this.val = val;
            this.ptr = ptr;
        }
//该status内嵌有compareTo方法，用来对输入的节点进行排序。此方法主要用于对整个链表的值进行排序。
        public int compareTo(Status status2) {
            return this.val - status2.val;
        }
    }

    PriorityQueue<Status> queue = new PriorityQueue<Status>();

    public ListNode mergeKLists(ListNode[] lists) {
        for (ListNode node: lists) {
            if (node != null) {
            //将链表数组中的链表注入队列里面
                queue.offer(new Status(node.val, node));
            }
        }
        //创建新链表进行整合
        ListNode head = new ListNode(0);
        ListNode tail = head;
        while (!queue.isEmpty()) {
		//此时queue内第一个链表，必定是首节点值最小的链表，将其取出，并且使用tail链表连接值
            Status f = queue.poll();![在这里插入图片描述](https://img-blog.csdnimg.cn/20210702190847299.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMzY4NTc3,size_16,color_FFFFFF,t_70)

            tail.next = f.ptr;
            tail = tail.next;
            if (f.ptr.next != null) {
                queue.offer(new Status(f.ptr.next.val, f.ptr.next));
            }
        }
        return head.next;
    }
}

在这里插入图片描述
在这里插入图片描述

排序链表
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
进阶：
你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

示例 1：
在这里插入图片描述
输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：
在这里插入图片描述

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]
示例 3：

输入：head = []
输出：[]

提示：
链表中节点的数目在范围 [0, 5 * 104] 内
-105 <= Node.val <= 105

因为要求是O（nlogn），所以考虑到的排序算法有堆排序，快速排序，分治排序。此处选择的是分治排序。通过快慢指针来进行链表的取中计算。

class Solution {
    public ListNode sortList(ListNode head) {
        return merge(head,null);
    }
    //此为分治算法的细分过程，将链表细分至节点，再从节点进行合并
    public ListNode merge(ListNode pre,ListNode end){
    //如果pre为空，则说明此越界不为节点。
        if(pre==null){
            return null;
        }
        //如果pre的下一个节点为end，则说明此链表区段为节点状态，已经无法继续细分
        if(pre.next==end){
            pre.next=null;
            return pre;
        }
        //快慢指针设立
        ListNode slow = pre;
        ListNode fast = pre;
        //快慢指针后移
        while(fast!=end){
            slow = slow.next;
            fast = fast.next;
            if(fast!=end){
                fast=fast.next;
            }
        }
        ListNode mid=slow;
        //递归思想，细分再合并
        ListNode leftList=merge(pre,mid);
        ListNode rightList=merge(mid,end);
        return mergeCount(leftList, rightList);
    }
    public ListNode mergeCount(ListNode pre,ListNode end){
    //两个列表按照节点的大小顺序进行合并
        ListNode node = new ListNode(0);
        ListNode temp = node;
        while(pre!=null||end!=null){
            int numPre = pre==null?Integer.MAX_VALUE:pre.val;
            int numEnd = end==null?Integer.MAX_VALUE:end.val;
            if(numPre<numEnd){
                temp.next=new ListNode(numPre);
                temp = temp.next;
                pre=pre.next;
            }else{
                temp.next=new ListNode(numEnd);
                temp=temp.next;
                end=end.next;
            }
        }
        return node.next;
    }
}

在这里插入图片描述

在这里插入图片描述

qq_42368577
关注
专栏目录
编程算法集锦
fakerth的博客
12-21 2513
编程算法集锦
算法集锦（NO.3）链表
qq_42368577的博客
07-03 147
算法集锦（NO.3） 链表 加快进度 两两交换链表中的节点 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 1： 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 提示： 链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100 进阶：你能在不修改链表节点值的情况下
算法集锦（NO.1）链表
qq_42368577的博客
07-01 202
算法集锦（NO.1） 链表 DAY1:我一定会攻克它 两数相加 给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l
算法集锦（NO.5）高频算法
qq_42368577的博客
07-06 261
算法集锦（NO.5） 高频习题 岛屿数量 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1： 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0”] ] 输出：1 示例 2： 输入：gri
算法题回顾：双指针链表系列集锦
Briwisdom的博客
04-07 666
如下示意图，首次相遇，slow走了k步， fast走了2k步，环的长度是k, 假设相遇节点离环的起点距离是n, 则从头节点到slow位置是k, 从头节点到环起点begin是k-n。判断环的起点：只需要在fast和slow相遇时候，将slow节点重新指向头节点，然后slow和fast指针开始同步前进，当再次相遇时候，即为环的起始节点。基本版本：遍历两遍链表，第一遍 知道链表的长度n,第二遍，倒数第k个节点，就是正数第n-k+1个节点，输出第n-k+1个节点。给一个链表数组，每个链表都是升序排列。
前端面试题集锦——算法
捣蛋龙的博客
09-19 1648
时间复杂度（Time complexity）是一个函数，它定性描述该算法的运行时间。这是一个代表算法输入值的字符串的长度的函数. 时间复杂度常用大O表述，不包括这个函数的低阶项和首项系数。是什么?执行当前算法需要占用多少内存空间表示法O(1)、O(n)、O(n^2)…空间复杂度基本上是O(1)或者O(N)，其它的空间复杂度不常见。假设开一个N*N的数组，那么它的空间复杂度是O(N^2)。结构体不讨论结构体个数，只看整体。不看具体，只看量级。链表是由多个元素组成的列表，链表中的元素储存不连续，用next指针连
面试集锦之算法
qq_45832807的博客
01-14 638
算法知识总结 本部分主要是笔者在学习算法知识和一些相关面试题所做的笔记，如果出现错误，希望大家指出！ 目录 常用算法和数据结构总结 排序 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 基数排序 快速排序相对于其他排序效率更高的原因 系统自带排序实现 稳定性 排序面试题目总结 树 二叉树相关性质 满二叉树 完全二叉树 平衡二叉查找树（AVL） B-树 B 树 数据库索引 红黑树 Huffman 树 二叉查找树 求解二叉树中两个节点的最近公共祖先节点 链表 反转单向链表
题海拾贝No.7|C语言笔试小题目集锦
weixin_44035986的博客
05-27 171
语言笔试小题目题目及解析 题目及解析 1、关键字static的作用是什么？ 答 ：这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用： 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。（本地化数据和代码范围的好处
题海拾贝No.8|C语言笔试小题目集锦
weixin_44035986的博客
07-04 245
C语言笔试小题目题目及解析 题目及解析 1、什么是预编译,何时需要预编译? 答：预编译又称为预处理,是做些代码文本的替换工作。处理#开头的指令,比如拷贝#include包含的文件代码，#define宏定义的替换,条件编译等，就是为编译做的预备工作的阶段，主要处理#开始的预编译指令，预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。c编译系统在对程序进行通常的编译之前，先进行预处理。 c提供的预处理功能主要有以下三种： 1）宏定义　2）文件包含　3）条件编译 2、关键字const
手撕算法面试题集锦(剑指offer)_python实现
UCASer
08-16 3065
python实现
ACM算法模板小汇总
羽歌Yo的博客
06-24 2574
一篇想到哪写到哪 · 不太全面的模板大集锦。
编程实践精华总结集锦系列2: SpringBoot/Maven/IDEA/Java/Kotlin/Redis等等
程序员光剑
07-24 8959
Go Quick Start 极简教程Go官网：https://golang.org/文档：https://golang.org/doc/开发环境配置下载 Go：（官网）https://g...
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 389
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
【百日算法计划】：每日一题，见证成长（016）
码上一元
09-18 290
百日算法计划：环形链表
尊享面试100题
qq_71286244的博客
09-21 257
尊享面试100题
[ABC330E] Mex and Update
2301_80882026的博客
09-18 874
给定一个序列，支持单点修改，每次修改后输出全局mex。一个序列的mex定义为，序列中最小的没有出现过的非负整数。
二分系列(二分答案最大值)9/15.16
2301_78191305的博客
09-16 1014
给你一批机器，及其它制作一块合金所需要的不同种类金属的个数。第一台机器制作一块合金，需要一块A金属、一块B金属、一块C金属。我们对每一类机器所需要的各种种类的金属进行判断，如果仓库里面有，就不需要花钱；如果mid-index<1的，要计算有多少个1。前n项和:(mid-1+1)*(mid-1)/2+leftCount-(mid-1);根据贪心:以index为中心，向两边依次-1，直到减到1为止。如果mid-rightCount<1,先计算多少个1，xxx。
代码随想录打卡Day39
最新发布
weixin_52151595的博客
09-21 173
今天是打家劫舍专题，三道题全都看了讲解，第一次做感觉确实是无从下手。。。不过了解了原理之后代码很快就写出来了。
已知f为单链表的表头指针，链表中存储的是6个整型数据，请用java实现下列运算的递推算法。 1.求链表的结点个数 2.求所有整数的平均值。
04-10
2. 求所有整数的平均值的递推算法： ``` public double getAverage(ListNode head) { int sum = 0; int count = 0; ListNode p = head; while (p != null) { sum += p.val; count++; p = p.next; } return...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值