【LC】反转链表, 相交链表, 环形链表

已于 2023-05-05 19:20:52 修改
阅读量540 收藏 8
点赞数 17
分类专栏： # 菜鸟刷题 # 数据结构 文章标签： 链表 数据结构 java leetcode 算法
于 2022-10-06 00:02:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trong_/article/details/127178643
版权

在这里插入图片描述✨博客主页: XIN-XIANG荣
✨系列专栏:【LeetCode/牛客刷题】
✨一句短话: 难在坚持,贵在坚持,成在坚持!

文章目录

1. 反转链表(lc206)

题目描述:

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

img

示例 1：

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

输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]

输出：[2,1]

示例 3：

输入：head = []

输出：[]

提示：

链表中节点的数目范围是 [0, 5000]

-5000 <= Node.val <= 5000

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/reverse-linked-list

解题思路：

遍历链表 , 将链表的第一个节点当作新链表的头节点 , 将其他节点完成头插操作即可 , 要注意的是节点的头插操作要改变节点中指针域引用的指向 , 所以在完成头插操作前 , 需要先记录下一个节点的位置 , 否则会与下一个节点失联 .

代码实现：

/**
 * 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;
        }
        //链表中是否只有一个节点
        if(head.next == null) {
            return head;
        }
        ListNode cur = head.next;
        head.next = null;
        //从第二个节点开始进行头插
        while(cur != null) {
            //记录下一个节点
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    }
}

其他写法:
这里与上面的写法稍有不同, 不过核心思路是一样的.

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode prev = null;
        ListNode curNext = null;
        while (cur != null) {
            curNext = cur.next;
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        return prev;
    }
}

提交结果：

img

2. 反转双链表

反转双向链表和单链表的反转类似, 只是每个节点要多处理一次每个节点的前驱指针.

实现代码如下:

public class DoubleNode {
	public int value;
	public DoubleNode last;
	public DoubleNode next;

	public DoubleNode(int data) {
		value = data;
	}

	public static DoubleNode reverseDoubleList(DoubleNode head) {
		DoubleNode cur = head;
		DoubleNode prev = null;
		DoubleNode curNext = null;
		while (cur != null) {
			curNext = cur.next;
			cur.next = prev;
			cur.last = curNext;
			prev = cur;
			cur = curNext;
		}
		return prev;
	}
}

3. 相交链表(lc160)

题目描述:

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

img

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

  • intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
  • listA - 第一个链表
  • listB - 第二个链表
  • skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
  • skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

img

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at ‘8’

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。

在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：

img

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Intersected at ‘2’

解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。

在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

img

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2

输出：null

解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。

由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。

这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m

listB 中节点数目为 n

1 <= m, n <= 3 * 104

1 <= Node.val <= 105

0 <= skipA <= m

0 <= skipB <= n

如果 listA 和 listB 没有交点，intersectVal 为 0

如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/intersection-of-two-linked-lists

解题思路：

两个链表的相交节点的引用一定是相同的 , 题目需要我们找到这个节点并返回 ;

可以这样实现 , 先分别求出两个链表的长度并求出两个链表长度的差值len , 声明引用 pl(指向长链表) 和 ps(指向短链表) , 让pl先走len步 , 此时再让pl和ps同时走 , 如果 pl 和 ps 相等且不为null , 那么此时就找到了相交的节点 .

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
       //求出两个链表的长度并进行比较
        int lenA = 0;
        int lenB = 0;
        ListNode pl = headA;//pl指向长链表
        ListNode ps = headB;//ps指向短链表
        while(pl != null) {
            pl = pl.next;
            lenA++;
        }
        while(ps != null) {
            ps = ps.next;
            lenB++;
        }
        pl = headA;
        ps = headB;
        
        int len = lenA - lenB;
        if(len < 0) {
            pl = headB;
            ps = headA;
            len = lenB- lenA;
        }
        //让较长链表先走len步
        while(len > 0) {
            pl = pl.next;
            len--;
        }
        //此时pl和ps同时走
        while(pl != ps) {
            ps = ps.next;
            pl = pl.next;
        }
        if(pl != null) {
            return pl;
        }
        return null;
    }
}

提交结果：

img

4. 环形链表(lc141)

题目描述:

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1

输出：true

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0

输出：true

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1

输出：false

解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 10 ^ 4]

-105 <= Node.val <= 105

pos 为 -1 或者链表中的一个 有效索引 。

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/linked-list-cycle

解题思路：

快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针同时从链表起始位置移动，快指针一次移动两个节点 , 慢指针一次移动一个节点 , 如果链表带环则一定会在环中相遇 ; 否则快指针率先走到链表的末尾 , 此时表明链表不带环。

这里在解释一下为什么两个指针一定会在环中相遇 , 如果环存在的话 , 那么快指针一定先比慢指针先进入环 , 当慢指针进入环后 , 此时两个指针不管相差多少个节点 , 每次移动快指针走两步 , 慢指针走一步, 这样每次移动两个震指针之间的距离都会缩小一步 , 最终一定会相遇 (想象生活中在操场跑步) .

【扩展思考】:

  • 为什么快指针每次走两步，慢指针走一步可以实现相遇, 快指针设置为一次走3步，走4步，…n步可以吗？

假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快 指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离 就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指 针的，即相遇。

img

所以我们这里最好将快指针的步长设置为2步, 防止套圈情况的出现 .

代码实现：

/**
 * 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) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                return true;
            }
        }
        return false;
     }
}

提交结果：

img

5. 环形链表||(lc142)

题目描述:

给你一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1

输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0

输出：返回索引为 0 的链表节点

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1

输出：返回 null

解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 10 ^ 4]

-105 <= Node.val <= 105

pos 为 -1 或者链表中的一个 有效索引 。

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/linked-list-cycle

解题思路：

img

说明:

在存在环的情况下, H为链表的起始点，E为环入口点，M为快慢指针在环中的相遇点

设:

环的长度为R，H到E的距离为L ; E到M的距离为X

则M到E的距离为R-X

所以，快慢指针相遇时各自所走的路径长度:

fast: L +X +nR

slow: L + x

注意:

1.当慢指针进入环时，快指针可能已经在环中绕了n圈了，n至少为1 , 因为快指针先进环走到M的位置(此时慢指针还在还没有到过M)，两个指针最后又在M的位置相遇 ;

2.慢指针进环之后，快指针肯定会在慢指针走一圈之内追上慢指针 , 因为慢指针进环后，快慢指针之间的距离最多就是环的长度，而两个指针在移动时，每次它们至今的距离都缩减一步，因此在慢指针移动一圈之前快指针肯定是可以追上慢指针的 .

而快指针速度是满指针的两倍，因此有如下关系是:

2*(L+ X) =L+ X + nR

L+ X = nR

L = nR - X

所以我们让一个指针从链表起始位置运行，一个指针从相遇点位置绕环，每次都走一步，两个指针最终会在入口点的位置相遇 (这里可能不好理解 , 可以看下面的图理解一下)

img

代码实现：

/**
 * 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) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                break;
            }
        }
        if(fast == null || fast.next == null) {
            return null;
        }
        //找到入口点
        while(head != fast) {
            head = head.next;
            fast = fast.next;
        }
        return fast;
    }
}

提交结果：

img

韵秋梧桐
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
单链表反转 链表相交
03-15
实现了一个简单的java版本的单链表，链表反转和链表是否相交如果相交求相交节点。关于链表是否相交是一次阿里的面试的在线试题，挂的很彻底。然后就在网上找了几个实现思路自己用java做了一个简单的实现....
Leetcode 反转链表.js
02-21
LeetCode 206的题目是“反转链表”（Reverse Linked List），它要求将一个单链表的所有节点反转，并返回反转后链表的头节点。这是一个基础但非常重要的链表操作问题，它不仅考察了对链表数据结构的理解，还涉及到了...
LC链表（算法系列）
布鲁斯能上天的博客
09-12 136
练习题和复用代码提取 链表问题通用方法： 1.遍历结束条件：p=null || p.next=null 2.遍历的初始值：p=head 3.核心逻辑： 4.特殊情况处理（头节点，尾节点，空链表，考虑是否使用虚拟头节点） 链表中参数理解： “=”：可以理解为指向 左侧表示被赋值的变量；右侧表示取的值 203. 移除链表元素 1.遍历结束条件：prev.next=null 2.遍历的初始条件：prev=head 3.遍历的核心逻辑： if（prev.next.val==val）prev.next=prev.ne
lc链表（移除|设计|反转|交换|删除|环形|相交）
qq_45949816的博客
10-16 185
lc链表（移除|设计反转|交换|环形|相交）
lc[链表]---阶段总结
zjjaibc的博客
09-28 152
lc[链表]---阶段总结
lc刷题总结（链表第二次）
j15941558855的博客
11-16 105
【代码】lc刷题总结（链表第二次）
链表基础练习（C语言实现）
小何代码咖啡馆
02-21 922
回文链表，本质即为以中间节点为对称轴，如果中间节点的左右部分完全相等，则证明该链表为回文链表，根据这个特点，可以考虑思路：因为回文链表以中间节点为对称轴，所以先找到中间节点，因为中间节点的左右部分完全相等，所以将中间节点的后部分链表反转再与原链表的节点中的val进行比较，如果相等即为回文链表，不相等则不为回文链表。带头双向链表优化了四个指针为空的问题，为四个指针单独开辟两个空间作为头结点，遇到大于或者等于x的尾插到大链表的头结点处，遇到小于x的尾插到小链表的头节点处，此时不需要单独处理第一个节点。
算法刷题3-链表章节
qq_45488015的博客
04-23 1560
虚拟头结点遍历指针双指针递归算法。
代码随想录：链表
weixin_58073817的博客
04-23 324
代码随想录：链表
leetcode链表专题
qq_46071871的博客
05-11 117
链表专题，很多链表题目都是用双指针，使用画图能够快速理清思路
算法：栈和队列和链表
sjz_hahalala479的博客
05-25 232
栈和队列 最小栈 基于栈实现队列 实现栈的逆序，只能用递归操作和栈本身的函数实现。不能使用其它数据结构。 利用递归函数的函数栈 将栈中从顶到底按照从大到小排序，只许申请一个栈，除此之外可以申请新的变量，但不能申请额外的数据结构。 汉诺塔原理 滑动窗口的最大值 https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/ 双端队列 给定一个没有重复元素的数组arr，写出生成这个数组maxTree的函数。要求如果数组长度为N，时间复杂
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
Java语言实现反转链表代码示例
08-29
主要介绍了Java语言实现反转链表代码示例，小编觉得挺不错的，这里分享给大家，供需要的朋友参考。
lianbiao.rar_反转链表
09-20
链表反转，非常实用，就是例如链表123，可以通过此文件中的函数反转为321，针对的是单向链表
【数据结构】链表与顺序表的比较
SWsunlight的博客
06-01 905
顺序表和链表比较
数据结构-哈希表
weixin_42035282的博客
06-01 384
哈希表是一种高效的数据结构，它可以提供快速的插入、删除和查找操作。哈希表的基本思想是将键通过一个哈希函数映射到一个连续的地址空间上，然后在这个地址空间上进行查找、插入和删除操作。下面将详细介绍哈希表的相关概念和实现方法。
day2数据结构
m0_62438849的博客
05-31 276
L 因为L会发生变化 & 引用在 C 语言中，参数传递不支持引用（&）的方式，应该使用指针来传递参数数组的赋值不能使用 = 直接赋值整个数组。需要逐个赋值数组的元素，或者使用循环来初始化数组//定义线性表的最大长度int length;}SqList;return -1;i < 5;i++){\n");return 0;
数据结构：链式队列
最新发布
weixin_67035108的博客
06-03 506
链式队列，指的是使用链表实现的队列，是一种常见的数据结构。队列遵循先进先出（FIFO）的原则，即最先进入队列的元素将是最先被移除的元素。链式队列通过链表的动态特性来实现队列的插入和删除操作，提供了比静态数组实现的队列更高的灵活性。： 链式队列需要维护两个指针：队首指针（指向队列的第一个元素）和队尾指针（指向队列的最后一个元素）。： 由于链式队列的元素是动态添加的，因此需要使用动态内存分配来创建新的节点。： 链式队列由一系列节点组成，每个节点通常包含两个部分：数据部分和指向下一个节点的指针
leetcode 链表相交
09-16
链表相交是指两个链表在某个节点上有相同的引用，也就是说两个链表从某个节点开始后面的节点都是相同的。要找出链表相交的起始节点，可以按照以下步骤进行操作： 1. 首先，分别求出链表A和链表B的长度La和Lb。 2. 如果La大于Lb，则让链表A先向前移动La-Lb步。 3. 如果Lb大于La，则让链表B先向前移动Lb-La步。 4. 然后，让链表A和链表B同时向前移动，直到它们的当前节点相等为止。 5. 如果链表A和链表B在某个节点相交，则返回该节点作为相交的起始节点。 6. 如果链表A和链表B没有相交节点，则返回null。 所以，根据以上步骤，可以找到两个链表的相交起始节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

韵秋梧桐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值