leetCode141环形链表 Java实现(最通俗理解的双指针)

leetCode141:环形链表 Java实现(最通俗理解的双指针)

题目分析：

点我看原题

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

为了表示给定链表中的环，我们使用整数 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
解释：链表中没有环。

思路解析：

代码很少，思路和理解很关键

分析下面几个问题，带着问题我们进行讨论

1. 如果这个链表没有环的话，我们遍历是可以结束的！如果有环，则永远结束不了。
2. 如果循环结束不了（有环），我们需要一个结束条件，来结束循环。
3. 例如 在 1 -> 2 -> 3 -> 4 链表中，假设4指向了2，则我们该如何判断循环结束条件？
4. 如果有环，肯定是这样遍历的 1 -> 2 -> 3 -> 4 -> 2 -> 3 -> 4 -> 2 -> 3 -> 4 …
5. 我们发现，遍历出来的数据从环处开始重复之前的数据，我们先引出双指针概念。
6. 假如我们有一个遍历比较快的指针（每循环一次，跳过两个数据），有一个比较慢的指针（每循环一次，跳一个数据）
7. 如果在一定时间下，如果存在环，则快指针，会赶上慢指针，就像操场跑圈一样。
8. 我们如何确定，快的指针每次跳两个？因为如果快指针比慢指针都是一次跳一个数据，那么他们速度相等，加速度一样，则不会相遇
9. 故，我们快指针加速度比慢指针快才好，所以我们取2，如果倍数太大，会导致循环多次，出现错过的现象。
10. 取2的原因还有一个就是，因为我们慢指针也要向下走，所以我们快指针需要走下下一个才能判断环
11. 取2的最重要的原因是，两个节点就可以构成环，如果取3，则判断不出。 例如：1 2 1 2 1 2 1 2 1 2 1 2 1 2
12. 假如我们判断刚才那个链表是否有环，快指针fast为初始为2节点，步长为2个 ，慢指针slow初始化1节点，步长为1个
13. 第一次遍历：fast = 4 slow =2 ,不相等，没相遇。继续循环。
14. 第二次遍历：fast = 3 slow = 3 相等，相遇了，则存在环。

代码实现：（双指针）

/**
 * 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 fast = head.next;
        ListNode slow = head;
        while(fast!=slow){
            // 如果走到头了，那么无环
            if(fast == null || fast.next == null){
                return false;
            }
            // 快指针走两步，加速度为2
            fast = fast.next.next;
            // 慢指针正常走一步
            slow = slow.next;
        }
        return true;
    }
}

时间复杂度o（N），空间复杂度o（1），因为我们没有开辟多余的数据节点。