环形链表的兜兜转转

环形链表的兜兜转转

环形链表

给链表加环的逻辑

// pos 代表 尾节点指向 链表中某个节点的索引位置 (环的入口)
    public static void toCycle(ListNode node, int pos) {
        // 遍历  通过pos找到 入口对应的节点  记录下来
        // 遍历到尾节点时   设置为其next引用

        // 记录遍历的位置
        int cnt = 0;
        ListNode cycleNode = null;
        while (true) {
            // 判断是否是环的入口节点
            if (cnt == pos) {
                cycleNode = node;
            }

            // 判断是否是尾节点
            if (node.next == null) {
                node.next = cycleNode;
                return;
            }

            node = node.next;
            cnt++;
        }

    }

1）判断是否有环

https://leetcode-cn.com/problems/linked-list-cycle/

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

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

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

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

分析：

环形链表 其实是形成了一个圈
跑步时 快的人和慢的人在某一点相遇 这能倒推出跑道是环形的

“快慢指针” 构造一个遍历时 走一步的指针 为慢指针
走两步的指针 为快指针 如果两者在某节点相遇 可以断定链表为环形

 public static boolean hasCycle(ListNode head) {
        // 链表本身不能为空  或者只有一个节点  也是无环的
        if (head == null || head.next == null) {
            return false;
        }

        ListNode slow = head;
        ListNode fast = head;
        while (true) {
            // 没有环时  fast会先走到链表尾部
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
            if(slow != null) {
                System.out.print("slow走到" + slow.val);
            }
            if(fast != null) {
                System.out.println(",fast走到" + fast.val);
            }
            if (slow == fast) return true;
        }
    }

2) 求环的入口节点

https://leetcode-cn.com/problems/linked-list-cycle-ii/

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

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

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

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

分析：
“快慢指针” 第一次相遇后，让fast重新指向头结点head,slow保持不变。
fast和slow按照相同速度移动，第二次相遇后，此节点即为入口节点。

[3,2,0,-4]
slow 3 2 0 -4 走了三步
fast 3 0 2 -4 走了六步 （是slow的2倍）

fast - slow 的步数 其实是环的长度 6-3=3

相遇点为-4， 距离环的入口节点 步数为两步
（指的是 入口节点 通往相遇点的方向距离 2->0->-4）

因为 头结点 途经的路程 是从头结点出发 经过入口节点 到达相遇点的
头结点到入口节点的距离 为一步

因为环的长度已知
所以 从相遇点再行进多少步 能回到入口节点 = 环的长度 - 相遇点距离入口节点的步数

slow -4 2
fast 3 2

public static ListNode detectCycle(ListNode head) {
        // 链表本身不能为空  或者只有一个节点  也是无环的
        if (head == null || head.next == null) {
            return null;
        }

        ListNode slow = head;
        ListNode fast = head;
        while (true) {
            // 没有环时  fast会先走到链表尾部
            if (fast == null || fast.next == null) {
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
            if(slow != null) {
                System.out.print("slow走到" + slow.val);
            }
            if(fast != null) {
                System.out.println(",fast走到" + fast.val);
            }
            if (slow == fast) break;
        }

        // 第一次相遇后，让fast重新指向头结点head,slow保持不变。
        // fast和slow按照相同速度移动，第二次相遇后，此节点即为入口节点。
        fast = head;
        while (true){
            slow = slow.next;
            fast = fast.next;
            if(slow != null) {
                System.out.print("slow走到" + slow.val);
            }
            if(fast != null) {
                System.out.println(",fast走到" + fast.val);
            }
            if(slow == fast) return slow;
        }
    }