leetcode 链表总结-java

已于 2023-02-16 12:35:59 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： leetcode算法总结 文章标签： 链表 leetcode java
于 2022-08-31 23:16:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41810415/article/details/126634163
版权

文章目录

题目所属分类

关于链表的题目

链表题目的心得

1 哨兵

如果我们引入哨兵结点，在任何时候，不管链表是不是空，head结点都会一直指向这个哨兵结点。我们也把这种有哨兵结点的链表叫做带头链表。
这种做法多了一个节点的开销，但对于一些会操作到head结点的题目，会方便很多。例如上面的删除倒数第N个元素，倒置链表Ⅱ等。

2 分链解题

例如 No.86 Partition List（分隔链表），No.328 Odd Even Linked List（奇偶链表），可以考虑设置两个链表，将原有链表分为两个各自满足一定条件的链表，最终再将链表进行结合。

3 测试用例

在解答过程中，我一般考虑一下的边界条件：

链表为空
链表中只有一个结点
链表中只包含两个结点
代码在处理头结点跟尾结点是否存在什么问题

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

在这里插入图片描述

代码案例：输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

题解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head ;
        ListNode p = dummy ;
        while(p != null &&  p.next !=null){
            if(p.next.val == val ){
                p.next  =  p.next.next;
            }else {
                p = p.next ;
            }
        }
        return dummy.next;
    }
}

206. 反转链表（模板记住）

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

迭代解法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null) return null ;
        ListNode a = head , b = head.next ;
        while(b != null){
            ListNode c = b.next ;
            b.next = a ;//让第二个的指针 指向前一个
            a = b ;//a和b依次往后移动一位
            b = c;//所以这个时候要保存b,next点
        }
        head.next = null ;//反转之后的头结点变成了尾结点 所以head.next = null 
        return a ;//最后返回反转后的头节点a
    }
}

递归解法

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {//递归的话  把它当作黑箱子操作
    //考虑边界情况 为空或者 只有一个情况下 只需要返回头节点就可以了
        if(head == null || head.next == null) return head ;
        ListNode tail = reverseList(head.next);//以head.next为头的翻转 返回的是翻转后的头节点
        head.next.next = head ;//翻转后的尾节点 指向头节点
        head.next = null;            //头节点变成尾结点
        return tail ;//返回翻转后的头节点
    }
}

234. 回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
在这里插入图片描述

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

题解

分成三部分 一个是将后半段进行翻转
二是前后要对称
三是后一半要翻转回去 不翻转回去可能会出现死循环的问题 但是试了试 不翻转回去也可以 没报错
在这里插入图片描述
翻转之后
在这里插入图片描述

数数的方法 没有用快慢指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //知道链表的长度
        int n =  0;
        for(ListNode p = head ; p != null ; p = p.next ) n++;
        if(n <= 1 ) return true ;
        int half = n / 2;
        ListNode a = head ; 
        //找到要翻转的起点
        for(int i = 0 ; i < n - half   ;i++){// 要跳n-half次
        a = a.next;
        }
        ListNode b = a.next;
        //开始翻转
        for(int i = 0 ; i < half - 1 ; i++){
            ListNode c = b.next ;
            b.next = a;
            a = b ;
             b = c ;
        }
        //然后用两个指针 检查是否对称
        ListNode p = head , q = a ;
        boolean success = true ;
        for(int i = 0 ; i < half ; i++){
            if(p.val != q.val){
                success = false;
               break;
            }
            p = p.next ;
            q = q.next ;
        } 
        //将后一半翻转回去
        ListNode tail = a;
        b = a.next ;
         for(int i = 0 ; i < half - 1 ; i++){
            ListNode c = b.next ;
            b.next = a;
            a = b ;
             b = c ;
        }
        tail.next = null ;
        return success;
    }
}

快慢指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
       if(head == null || head.next == null) return true;
        ListNode slow = head, fast = head.next;
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //快慢指针 这时候慢指针到达一半
        //将右半部分的链表slow.next进行反转
        ListNode right = reverse(slow.next);
        //双指针
        ListNode p = head ;
        while(right != null ){
            if(p.val != right.val) return false;
            p = p.next ;
            right = right.next;
        }
        return true ;
           
         
    }
    public ListNode reverse(ListNode head){//翻转链表模板
        ListNode a = head , b = head.next;
        while(b != null){
             ListNode c = b.next ;
             b.next = a;
             a = b ; b = c ;
        }
       
        head.next = null ;
        return a ;
    }
}

237. 删除链表中的节点

在这里插入图片描述

在这里插入图片描述

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

题解

(链表操作) O(1)O(1)
由于是单链表，我们不能找到前驱节点，所以我们不能按常规方法将该节点删除。
我们可以换一种思路，将下一个节点的值复制到当前节点，然后将下一个节点删除即可。

时间复杂度分析：只有常数次操作，所以时间复杂度是 O(1) 。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

21 合并链表

环型链表所考的类型题 环入口 判断环 环个数 环种有几个节点
剑指offer 34. 链表中环的入口结点-java实现

环型链表(判断环)

在这里插入图片描述

题解

在这里插入图片描述

有环一定会相遇 无环的话快指针会走到空结点
用两个指针从头开始扫描，第一个指针每次走一步，第二个指针每次走两步。如果走到 null，说明不存在环；否则如果两个指针相遇，则说明存在环。

为什么呢？
假设链表存在环，则当第一个指针走到环入口时，第二个指针已经走到环上的某个位置，距离环入口还差 xx 步。
由于第二个指针每次比第一个指针多走一步，所以第一个指针再走 xx步，两个指针就相遇了。

时间复杂度分析：第一个指针在环上走不到一圈，所以第一个指针走的总步数小于链表总长度。而第二个指针走的路程是第一个指针的两倍，所以总时间复杂度是 O(n) 。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null)return false;
        ListNode one = head ;
        ListNode second = head ;
        while(second.next != null && second.next.next != null){
                one = one.next;
                second = second.next.next;
                if(one == second) return true;
        }
        return false;
    }
}

判断环形的入口节点

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null) return null ;
        ListNode fast = head;
        ListNode slow = head;
        while(fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast){
                slow = head;
                while(slow != fast){
                     slow = slow.next;
                    fast = fast.next ;
                }
               return slow ;
            }
        }
        return null ;
    }
}

143. 重排链表

上取整，不管四舍五入的规则，只要后面有小数前面的整数就加1。下取整，不管四舍五入的规则，只要后面有小数忽略小数给定。

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

题解

中点是n/2下取整 也就是n+1 / 2 下取整

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        //先获取长度
        int n = 0 ; 
        for(ListNode p = head ; p != null ; p = p.next ) n++;
        //快慢指针 到达一半  或者用数学的那种方法
        ListNode later = head ;
        for(int i = 0 ; i + 1 < (n+1)/2 ; i++){
            later = later.next ;
        }
        //翻转链表
        ListNode a = later  ;
        ListNode b = later.next ;
        while(b != null){
            ListNode c = b.next ;
            b.next = a ;
            a =  b ;
            b = c ;
        }
        later.next = null ;
        //交叉合并链表
        // ListNode cur = head ;
        // while(cur != null && a != null){
        //     ListNode cur_next = cur.next ;
        //     ListNode tail = a.next ;
        //     cur.next = a ;
        //     a.next = cur_next ;
        //     cur = cur_next ;
        //     a = tail ;
        // }
         while (head != null && head != a)
        {
            b = a.next;
            a.next = head.next;
            head.next = a;
            head = head.next.next;
            a = b;
        }
    }
}

148. 排序链表

92. 反转链表 II

61. 旋转链表

LeetCode 82. 删除排序链表中的重复元素 II

LeetCode 83. 删除排序链表中的重复元素

leetcode 86. 分隔链表

leetcode 328. 奇偶链表

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。

第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。

请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。

你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

在这里插入图片描述

输入: head = [1,2,3,4,5]
输出: [1,3,5,2,4]

题解

从前往后遍历整个链表，遍历时维护四个指针：奇数链表头结点，奇数链表尾节点，偶数链表头结点，偶数链表尾节点。

遍历时将位置编号是奇数的节点插在奇数链表尾节点后面，将位置编号是偶数的节点插在偶数链表尾节点后面。

遍历完整个链表后，将偶数链表头结点插在奇数链表尾节点后面即可。

时间复杂度分析：整个链表只遍历一次，所以时间复杂度是 O(n)，遍历时只记录了常数个额外的指针，所以额外的空间复杂度是 O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head == null || head.next == null)return head ;
        //odd是奇数  even是偶数
         ListNode oddHead = head, oddTail = oddHead;
         ListNode evenHead = head.next, evenTail = evenHead;
        //遍历时将位置编号是奇数的节点插在奇数链表尾节点后面，
        //将位置编号是偶数的节点插在偶数链表尾节点后面。
        for(ListNode p = head.next.next ; p != null ;){
            //此时p是奇数的
             //可以分开来写 等同于oddTail.next = p;  oddTail  = oddTail.next ;      
            oddTail  = oddTail.next = p;       
            p = p.next ;
            if(p != null){
                 evenTail.next = p ;
                evenTail = evenTail.next  = p;
                p =p.next ;
            }
        }
    //遍历完整个链表后，将偶数链表头结点插在奇数链表尾节点后面即可。
         oddTail.next = evenHead ;
         evenTail.next = null;
         return oddHead ;
    }
}

leetcode 19. 删除链表的倒数第 N 个结点-java实现

leetcode 21. 合并两个有序链表-java版

leetcode 23. 合并K个升序链表-java版

依嘫_吃代码
关注
专栏目录
javalruleetcode-leetcode-algorithms-java:leetcode算法笔记-java
06-29
压缩包文件“leetcode-algorithms-java-master”暗示这是一个开源项目，包含了一个完整的算法解决方案集，适合于学习、参考和实践。在实际开发过程中，了解和掌握 LeetCode 中的算法可以帮助程序员更有效地解决问题...
leetcode-LeetCode-Java-Solutions:Java中LeetCode在线判断问题的解决方案
06-29
《LeetCode-Java-Solutions: Java中LeetCode在线判断问题的解决方案详解》 在编程学习与进阶的过程中，LeetCode是一个不可多得的资源库，它提供了大量的算法题目供程序员练习，以提升自身的编程能力和算法水平。...
leetcode java 链表
weixin_51666505的博客
05-10 257
删除链表的倒数第 N 个结点 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val,...
LeetCode排序链表（JAVA）
weixin_43589025的博客
06-03 321
问题： 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 代码实现 public class 排序链表 { public static void main(String[] args) { ListNode no
LeetCode 链表题 ( Java )
大数据的奇妙冒险
02-16 681
通俗易懂总结常见链表题
LeetCode160.相交链表（Java实现）
Teacher_HENG
04-01 529
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 思路： 1.链表判空 2.设置pa从headA开始，设置pb从headB开始 3.pa，pb同时向后移动，直到两者有一个为空则结束，表示无交点 4.在3循环中，如果出现pa相遇pb，则此处为交点 5.pa和pb后移一位 6.如果pa和pb均换...
java链表及实现leetcode题
weixin_33688840的博客
12-03 309
2019独角兽企业重金招聘Python工程师标准>>> ...
leetcode下载-LeetCode-Python-Java:zhouzhenping/LeetCode-Python&Java
06-29
LeetCode-Python-Java zhouzhenping/LeetCode-Python&Java 参考代码来源 力扣（LeetCode） 链接： 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 Github 01 两数之和 给定一个整数数组 ...
判断链表是否为回文链表leetcode-JAVA-coding-interview-Balazs:leetcode.com,algoexper
07-01
JAVA-coding-interview-Balazs 帮助： 这个 repo 包含大约 300 个 Leetcode.com 和 85 个 Algoexpert.io 问题以及使用 Swift 和 Python 的解决方案 这个 repo 包含我用Java和Python编写的算法问题的解决方案。 • •...
leetcodeoj和leetcode-leetcode-in-java:这是leetcode学习笔记。（在Java中）
07-07
#Leetcode-In-Java 代码并不全是本人写的，有的参考了网络上其他前辈的想法，但都能在OJ上AC。 ###索引 1 . Two-Sum 要点： - 利用java中Array对象的sort方法排序，使得整个数组呈升序状态 - 再利用两段取点...
LeetCode（Java版）19. 删除链表的倒数第N个节点
SOARING
05-04 1160
解法1：不需要去遍历两次，一次即可，思路是，用两个指针p，q先指向头节点，让q指针走到第n个位置，然后两个指针同时往后走，走到q.next==null是说明p已经到达倒数第n个节点的前面的那个节点，此时删除下一个节点即可。 注意：当删除头节点和只有一个元素的情况。 执行用时 :2 ms,95.78% .内存消耗 :34.4 MB, 89.34% 。 /** * Definition...
数据结构学习笔记 1-1链表概述及LeetCode真题图解（Java）
最新发布
m0_60667010的博客
03-31 886
我们只需要遍历这个链表，在遍历过程中记录我们遍历的每个结点。如果遇到。
LeetCode算法（Java）链表部分
m0_62388538的博客
09-16 85
链表#Java#数据结构与算法#LeetCode
leetcode160. 相交链表（java实现）
Hello什么来着？
04-02 606
编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如...
LeetCode 141. 环形链表（java 实现）
ccccc1997的博客
08-14 1527
给定一个链表，判断链表中是否有环。 进阶： 你能否不使用额外空间解决此题？ /** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * nex...
LeetCode 链表解题汇总 Java版
weixin_34219944的博客
04-21 275
19. Remove Nth Node From End of List (Medium) 移除倒数第N个节点 19. Remove Nth Node From End of List 代码： 先判断经过n个节点后是否刚好到了末尾，是的话链表长度为n，第n个节点就是头结点，直接返回head.next的链表。 经过n个节点后，还未到末尾，此时开启双指针，slow和fast同时往后走，fast和s...
leetcode：反转链表（java）
从一点一滴做起
04-12 767
题目 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ java /** * Definition for singly-linked list. * public class Lis...
LeetCode第23题：合并K个有序链表（JAVA实现）
FaustoPatton的博客
09-17 2324
题目： 我的解答： 思路很简单，把所有的数据先读到ArrayList中然后转到数组中，然后排序，然后构建新链表 代码： /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { v...
LeetCode-合并两个有序链表(java实现)
热门推荐
fengpojian的博客
08-03 2万+
    题目如下      看完题目之后，思考的结果是用递归做应该是最佳的选择。但无奈水平真的有限，没有想出来如何用设计递归。提交的时候就没有用递归实现，运行结果可想而知：23ms。看了第一名的用时是5ms，而且代码简洁优美，不得不佩服 /** *Definition for singly-linked list */ class ListNode{ int val; L...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

依嘫_吃代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值