55 剑指offer--链表--链表中环的入口结点

最新推荐文章于 2024-09-14 12:45:10 发布
最新推荐文章于 2024-09-14 12:45:10 发布
阅读量314 收藏
点赞数
分类专栏： 剑指offer 文章标签： 链表中环的入口结点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41563161/article/details/103239650
版权

                                     链表中环的入口结点

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead == null){
            return null;
        }
        ListNode p1 = pHead;
        ListNode p2 = pHead;
        while(p2 != null && p2.next != null){
            p1 = p1.next;
            p2 = p2.next.next;
            if(p1 == p2){
                p2 = pHead;
                while (p1 != p2){
                    p1 = p1.next;
                    p2 = p2.next;
                }
                return p1;
            }
        }
        return null;
    }
}

判断有没有环、

public class Solution {
    public boolean hasCycle(ListNode head) {
      ListNode slow=head,fast=head;//双指针 ：快慢指针
        while (fast!=null && fast.next!=null)
        {
            slow = slow.next;
            fast = fast.next.next;
            if(slow==fast)
                return true;
        }
        return false;
    }
}

不用快慢指针判断链表中是否有环

方法一：HashSet
定义一个HasshSet用来存放节点的引用，并将其初始化为空，从链表的头节点开始向后遍历，每遍历到一个节点就判断HashSet中是否有这个节点的引用。如果没有，说明这个节点是第一次访问，还没有形成环，那么将这个节点的引用添加到HashSet中去。如果在HashSet中找到了同样的节点，那么说明这个节点已经被访问了，于是就形成了环。这种方法的时间和空间复杂度都为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) {
        //创建集合对象
        HashSet<ListNode> set = new HashSet<ListNode>();
        //遍历链表
        ListNode p = head;
        while (p != null){
           if (set.contains(p)){
               return true;
           }else{
               set.add(p);
           }
           p = p.next;
        }
        return false;
    }
}

 

题目

一个链表中包含环，请找出该链表的环的入口结点。

思路

思路 1

可以用两个指针来解决这个问题。先定义两个指针P1和P2指向链表的头结点。如果链表中的环有n个结点，指针P1先在链表上向前移动n步，然后两个指针以相同的速度向前移动。当第二个指针指向的入口结点时，第一个指针已经围绕着揍了一圈又回到了入口结点。

以下图为例，指针P1和P2在初始化时都指向链表的头结点。由于环中有4个结点，指针P1先在链表上向前移动4步。接下来两个指针以相同的速度在链表上向前移动，直到它们相遇。它们相遇的结点正好是环的入口结点。

现在，关键问题在于怎么知道环中有几个结点呢？

可以使用快慢指针，一个每次走一步，一个每次走两步。如果两个指针相遇，表明链表中存在环，并且两个指针相遇的结点一定在环中。

随后，我们就从相遇的这个环中结点出发，一边继续向前移动一边计数，当再次回到这个结点时，就可以得到环中结点数目了。

思路 2

1、哈希表

遍历整个链表，并将链表结点存入哈希表中（这里我们使用容器set），如果遍历到某个链表结点已经在set中，那么该点即为环的入口结点；

2、两个指针

如果链表存在环，那么计算出环的长度n，然后准备两个指针pSlow，pFast，pFast先走n步，然后pSlow和pFase一块走，当两者相遇时，即为环的入口处；

3、改进

如果链表存在环，我们无需计算环的长度n，只需在相遇时，让一个指针在相遇点出发，另一个指针在链表首部出发，然后两个指针一次走一步，当它们相遇时，就是环的入口处。（这里就不说明为什么这样做是正确的，大家可以在纸上推导一下公式）

代码

代码1

public class ListNode {
    int val;
    /**
     *保存链表的值
     */
    ListNode next;
    /**
     *下一个结点
     */
    ListNode(int x) {
          val = x;
          next = null;
      }
      @Override
      public String toString(){
        return val+"";
      }
}

public class hasCycle {
    public static void main(String[] args) {
       // test1();
        //test2();
        test3();
    }
    // 1->2->3->4->5->6 <-+
    //                |   |
    //                +---+
    private static void test3() {
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        ListNode n5 = new ListNode(5);
        //ListNode n6 = new ListNode(6);

        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n3;
       // n6.next = n3;

        System.out.println(hasCycle(n1));
    }

    private static void test2() {
        // 1->2->3->4->5->6
        //       ^        |
        //       |        |
        //       +--------+
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        ListNode n5 = new ListNode(5);
        ListNode n6 = new ListNode(6);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        n6.next = n3;
        System.out.println(hasCycle(n1));
    }

    //1->2->3->4->5->6
    private static void test1() {
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        ListNode n5 = new ListNode(5);
        ListNode n6 = new ListNode(6);
        n1.next = n2;
        n2.next = n3;
        n3.next = n4;
        n4.next = n5;
        n5.next = n6;
        System.out.println(hasCycle(n1));
    }

    public static ListNode  hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        //首先定义两个指针
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast) {
                fast = head;
                while(slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return slow;
            }
        }
        return null;
    }
}

代码2

/**
 * 链表中环的入口节点
 * 
 * 思路：
 *      1.判断是否存在环，并找到快慢两个指针相遇的位置
 *      2.根据找到的这个相遇位置，统计环中节点的数目n，先让快指针走n步，然后快慢两个指针一起运动，快慢指针相遇时的节点就是环的入口节点
 */
public class EnterNodeInLink {

    public ListNode getEnterNode(ListNode head){
        //参数校验
        if(head == null){
            return null;
        }

        //如果有环，第一个和第二个指针在环中相遇时的节点
        ListNode meetingNode = meetingNode(head);

        int ringLength = 0;                 //环的长度
        if(meetingNode != null){            //如果存在环，就求出环的长度
            ListNode tempNode = meetingNode;
            meetingNode = meetingNode.next;
            while(meetingNode != tempNode){
                ringLength++;
                meetingNode = meetingNode.next;
            }
            ringLength++;
        }else{                              //如果不存在环，就返回null
            return null;        
        }

        ListNode ahead = head;              //第一个指针
        ListNode behind = head;             //第二个指针

        while(ringLength > 0){
            ahead = ahead.next;             //第一个指针先在链表上向前移动ringLength步
            ringLength--;
        }
        while(ahead != behind){
            ahead = ahead.next;
            behind = behind.next;
        }
        return behind;
    }

    //在链表存在环的情况下，找到一快一慢两个指针相遇的节点
    public ListNode meetingNode(ListNode head){
        //参数校验
        if(head == null){
            return null;
        }
        ListNode behind = head.next;        //后面的指针

        //如果只有一个节点直接返回null
        if(behind == null){
            return null;
        }
        ListNode ahead = behind.next;       //前面的指针

        while(behind != null && ahead != null){
            if(behind == ahead){
                return ahead;
            }
            //behind指针在链表上移动一步
            behind = behind.next;
            //ahead指针在链表上移动两步
            ahead = ahead.next;
            if(ahead != null){
                ahead = ahead.next;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        EnterNodeInLink test = new EnterNodeInLink();

        ListNode head = new ListNode();
        ListNode temp1 = new ListNode();
        ListNode temp2 = new ListNode();
        ListNode temp3 = new ListNode();
        ListNode temp4 = new ListNode();
        ListNode temp5 = new ListNode();

        head.value=1;
        temp1.value=2;
        temp2.value=3;
        temp3.value=4;
        temp4.value=5;
        temp5.value=6;
        head.next=temp1;
        temp1.next=temp2;
        temp2.next=temp3;
        temp3.next=temp4;
        temp4.next=temp5;
        temp5.next=null;

        ListNode resultNode = test.getEnterNode(head);
        if(resultNode != null){
            System.out.println(resultNode.value);
        }else{
            System.out.println("您输入的参数有误！");
        }
    }
}

class ListNode{
    int value;
    ListNode next;
}

LeetCode

环形链表

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

示例 1：

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

输出：true

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

示例 2：

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

输出：true

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

示例 3：

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

输出：false

解释：链表中没有环。

代码

public boolean hasCycle(ListNode head) {
    Set<ListNode> nodesSeen = new HashSet<>();
    while (head != null) {
        if (nodesSeen.contains(head)) {
            return true;
        } else {
            nodesSeen.add(head);
        }
        head = head.next;
    }
    return false;
}

public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}


public class Solution {
    public boolean hasCycle(ListNode head) {
      ListNode slow=head,fast=head;//双指针 ：快慢指针
        while (fast!=null && fast.next!=null)
        {
            slow = slow.next;
            fast = fast.next.next;
            if(slow==fast)
                return true;
        }
        return false;
    }
}

环形链表 II

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

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

示例 1：

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

输出：tail connects to node index 1

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

示例 2：

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

输出：tail connects to node index 0

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

示例 3：

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

输出：no cycle

解释：链表中没有环。

链表的中间结点

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

 

示例 1：

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

输出：此列表中的结点 3 (序列化形式：[3,4,5])

返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。

注意，我们返回了一个 ListNode 类型的对象 ans，这样：

ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6]

输出：此列表中的结点 4 (序列化形式：[4,5,6])

由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。
提示：

给定链表的结点数介于 1 和 100 之间。

public ListNode middleNode(ListNode head) {
    if(head == null || head.next == null){
        return null;
    }
    ListNode first = head;
    ListNode second = head;
    while (second != null && second.next != null){
        first = head.next;
        second = head.next.next;
    }
    return first;
}

判断链表是否有环 及 寻找环的入口
zwwhsxq的博客
07-10 1803
判断链表是否有环及寻找环入口的思路、证明、代码
剑指offer---链表中环的入口结点
weixin_41563161的博客
01-28 173
这道题也是面试中必考的一道题。通常面试官让我们手撕出来，并且让我们讲解思路，来一起看看吧！ 1.序 首先我们来看一下比较简单的，如何判断链表是否成环。 快慢指针 public class Solution { public boolean hasCycle(ListNode head) { ListNode slow=head,fast=head;//双指针 ：快慢指针 while (fast!=null && fast.next!=null)
剑指offer--链表中环的入口结点
fxjzzyo的博客
07-14 254
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 思路 遍历链表的过程中，将遍历过的结点记录起来，同时判断遍历的下一个结点是否在记录中，也就是判断是否遍历过它。如果遍历过说明存在环，且这个结点就是环的入口结点。 C++代码 /* struct ListNode { int val; struct ListNode *next...
剑指offer-链表中环的入口结点
六月二十七的博客
03-21 152
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } */ public class Solution { pu...
剑指Offer-链表中环的入口结点
疯狂的兔子
04-25 218
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 解题思路—HashMap：使用HashMap存储链表结点，当链表结点重复时，即有环时，输出当前结点即可。 解题思路—快慢指针：这里有一个可以判断链表是否有环并且找到环入口的既定方法，这个方法很巧妙： 设置两个指针pfast和pslow，同时从链表头出发，pfast一次走两步，pslow一次走一步，如果链表有环，...
剑指offer---链表中环的入口节点
大猫
08-02 181
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 解题思路： 对于这个题，我们可以选择遍历一遍整个链表，每次用一个list存起来，然后每存一个节点的时候都看一下list里面是否存在这个节点，如果存在，就为环。且因为我们是从头开始遍历，所以第一个后来遍历到并且存在于list里面的节点肯定是环的入口。 ...
9 链表中环的入口结点--剑指offer--python实现
CSDN_SUSAN的博客
11-13 423
文章目录1. 题目描述2. 题目解析2.1 考察问题2.2 解决方法2.3 优化分析3. 代码实现3.1 遍历链表，list计数3.2 快慢指针，规律发现 1. 题目描述   描述：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 2. 题目解析 2.1 考察问题   本问题考察的是链表的遍历和快慢指针应用。   环的入口节点，说明是遍历链表，第一次重复的节点。 2.2 ...
牛客网剑指Offer-链表篇-JZ23 链表中环的入口结点
最新发布
技术卷的博客
09-14 795
给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。
【剑指offer-C++】JZ23：链表中环的入口结点
❀雾里看花花里看雾❀
03-07 170
【剑指offer-C++】JZ23：链表中环的入口结点
python-剑指offer第55题链表中环的入口结点
08-06
python python_剑指offer第55题链表中环的入口结点
23：链表中的环的入口结点（剑指offer第2版Python）
01-21
寻找链表中环的入口结点主要分成三个步骤： 首先是设置两个快慢指针，如果快慢指针相遇，则快慢指针必然都在环中； 然后从相遇的地方设置一个指针向后遍历并记录走的步数，当这个指针重新指到开始的位置的时候，当前...
剑指Offer---Java版代码
12-20
5. 链表：包括链表中倒数第K个结点，链表中环的入口结点，反转链表，合并两个排序的链表等。 6. 查找算法：如数值的整数次方，数组中出现次数超过一半的数字等。 7. 动态规划：例如把数组排成最小的数，把数字翻译成...
46 剑指offer 孩子们的游戏（圆圈中最后剩下的数）
weixin_41563161的博客
01-24 2785
孩子们的游戏（圆圈中最后剩下的数） 题目 每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且...
二叉树的第k个结点（二叉搜索树的第k个结点）
weixin_41563161的博客
01-23 791
二叉树的第k个结点 题目描述 给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。 /* public class TreeNode { int val = 0; TreeNode left = null; Tree...
15 剑指offer--链表--反转链表
weixin_41563161的博客
10-16 786
反转链表 题目 输入一个链表，反转链表后，输出链表的所有元素。 思路 这个很简单，我们使用三个指针，分别指向当前遍历到的结点、它的前一个结点以及后一个结点。 在遍历的时候，做当前结点的尾结点和前一个结点的替换。 方法一：迭代 假设存在链表 1 → 2 → 3 → Ø，我们想要把它改成 Ø ← 1 ← 2 ← 3。...
5 剑指offer--栈队列--互相实现
weixin_41563161的博客
10-10 711
用两个栈实现队列 栈是一个非常常见的数据结构，它在计算机领域被广泛应用，比如操作系统会给每个线程创建一个栈用来存储函数调用时各个函数的参数、返回地址及临时变量等。桟的特点是后进先出，即最后被压 入 （push) 栈的元素会第一个被弹出（pop)。 通常栈是一个不考虑排序的数据结构，我们需要〇( n )时间才能找到...
52 剑指offer--正则表达式匹配（动态规划）
weixin_41563161的博客
09-17 671
正则表达式匹配 给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘*’ 匹配零个或多个前面的那一个元素 所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。 说明: s 可能为空，且只包含从 a-z 的小写字母。 p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。 示例 1: 输入: s = “aa” ...
22 59 （10）剑指offer 数据结构---二叉树的遍历 N叉树的层序遍历
weixin_41563161的博客
10-19 531
二叉树的遍历 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 前序遍历 // 用递归的方法进行先序遍历 public void...
14 剑指offer--链表--链表中倒数第k个数（链表中倒数第k个结点）
weixin_41563161的博客
10-16 506
链表中倒数第k个数 概述 鲁棒是英文Robust的音译，有时也翻译成健壮性。所谓的鲁棒性是指程序能够判断输入是否合乎规范要求，并对不符合要求的输入予以合理的处理。 当我们用一个指针 遍 历 链 表 不 能 解 决 问 题 的 时 候 ，可以尝试用两个指针 来 遍 历 链 表 可 以 让 其 中 一 个 指 针 遍 历 的 ...
链表基础与编程实践-C语言
- **带头结点链表**：在链表开始处添加一个额外的结点作为头结点，头指针指向头结点，简化对链表的操作，特别是在处理空链表或只有一个结点的链表时。 3. **带头结点编程实例**：在实际编程中，常常会在链表的开始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

haikuotiankongdong

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

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

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

打赏作者

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

抵扣说明：

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

余额充值