快慢指针问题

一，判断链表是否存在环：

1）题目链接：

力扣https://leetcode.cn/problems/linked-list-cycle/

141. 环形链表

难度简单1498

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

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

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目范围是 [0, 104]
• -105 <= Node.val <= 105
• pos 为 -1 或者链表中的一个 有效索引 。

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

·

2）思路+代码：

2.1）hash表判断节点重复：

        这个很简单，就是利用一个HashMap或者hashSet，遍历链表，不断将链表中的Node节点加入到hash表中，并判断hash表中是否存在重复的Node节点；

        如果是一个环，一定会进行重复遍历，则hash表便会判断出来；

        看代码：

/**
* 利用hash表判断重复
* @param head
* @return
*/
public boolean hasCycle2(ListNode head) {
	Set<ListNode> hashSet = new HashSet<>();
	while (head != null) {
		  boolean add = hashSet.add(head);
		  if (add) {
				head = head.next;
		  }else{
				return true;
		  }
	}
	return false;
}

·

2.2）双指针法-快慢指针：（重点）

/**
* 快慢指针的方式
*          1，双指针法，一个快指针，一个慢指针，
*          2，初始化，都指向头结点；
*          3，快指针一次走两步，慢指针一次走一步；
*          4.1，如果存在环，那么快慢指针一定会在环里边相遇！
*          4.2，如果不存在环，那么快指针会首先到达链表末尾，即ListNode.next==null；
* @param head
* @return
*/
public boolean hasCycle1(ListNode head) {
	ListNode fast = head; //快指针
	ListNode slow=head; //慢指针
	while (fast != null) {
		  try {
				fast = fast.next.next; //快指针一次走两步
				slow = slow.next; //慢指针一次走一步；
				if (Objects.equals(fast, slow)) {
					  return true; //快慢指针相遇，说明是个环；
				}
		  } catch (NullPointerException e) {
				//因为快指针一次走两步，有可能会出现空指针异常，此时也说明了不是环，则直接返回false；
                return false;
		  }
	}
	return false;
}

·

---

二，已知链表存在环，返回这个环的起始位置：

1）题目链接：

力扣https://leetcode.cn/problems/c32eOV/

剑指 Offer II 022. 链表中环的入口节点

难度中等57

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 链表中节点的数目范围在范围 [0, 104] 内
• -105 <= Node.val <= 105
• pos 的值为 -1 或者链表中的一个有效索引

进阶：是否可以使用 O(1) 空间解决此题？

·

2）思想：

1，我们设环的长度为l;

2，慢指针走了多远，我们设它走了k；

3，快指针走了多远，因为慢指针一次走一步，快指针一次走两步，所以快指针走了2k；

·

结论1，那快指针比慢指针多了哪些路径呢？

        首先，非环部分，快慢指针都走过了；

        所以，快指针多走了的路径就是环的部分，即多个环的长度，即2k-k=x*l；

        结论：k=x*l；

·

结论2，非环部分的长度？

        我们设相遇点与环起点的距离为m，又因为慢指针走了k，所以非环部分的长度为k-m；

如图所示：

·

结论3，相遇点到环起点的长度？

        我们知道环的长度为l，所以相遇点第1次到环起点的长度为1*l-m，

        相遇点第2次到环起点的长度为2*l-m，

        相遇点第x次到环起点的长度为：x*l-m；

·

结论4， 非环部分的长度 等于 相遇点第x次到环起点的长度；

        结论2中，我们知道非环部分的长度为：k-m；

        又结论1中我们知道，k=x*l；

        所以非环部分的长度为：x*l-m；

        结论3中我们知道，相遇点第x次到环起点的长度为：x*l-m；

        结论：非环部分的长度 == 相遇点第x次到环起点的长度；

        也就是说，如果我们有两个一样的指针a和b，a指针从链表head节点出发，b指针从相遇点出发，那么当a指针到达环起点的时候，b指针可能已经转了多圈，但是总之，此时的b指针也一定在环起点的位置。          

·

3）代码：

3.1）解题步骤：

        1，前期跟判断链表存在环是一样的，一个快指针，一个慢指针，直到快慢指针重合；

        2，快慢指针重合的位置，即相遇点，此时新建两个一样的指针，a指针从head节点出发，b指针从相遇点出发；

        3，当a指针和b指针重合的时候，该位置即为环起点的位置。

·

3.2）看代码：

/**
* 解题步骤：
* 1，前期跟判断链表存在环是一样的，一个快指针，一个慢指针，直到快慢指针重合；
* 2，快慢指针重合的位置，即相遇点，此时新建两个一样的指针，a指针从head节点出发，b指针从相遇点出发；
* 3，当a指针和b指针重合的时候，该位置即为环起点的位置。
*
* @param head
* @return
*/
public static ListNode detectCycle(ListNode head) {
	//base case特殊情况：
	if (head == null) {
		  return null;
	} else if (head.next == null) {
		  return null;
	}

	try {
		  //声明并初始化快慢指针：
		  ListNode fast = head;
		  ListNode slow = head;

		  while (true) {
				fast = fast.next.next; //快指针一次走两步
				slow = slow.next; //慢指针一次走一步
				//当快慢指针重合的时候，跳出循环：
				if (fast == slow) {
					  break;
				}
		  }

		  //当快慢指针重合的时候，跳出循环，此时重合为位置为相遇点：
		  ListNode xiangyuNode = fast;

		  //新建两个一样的指针，a指针从head出发，b指针从相遇点出发：
		  ListNode a = head;
		  ListNode b = xiangyuNode;
		  while (true) {
				//当a指针和b指针重合的时候，该位置即为环起点的位置。
				if (a == b) {
					  break;
				}
				a = a.next;
				b = b.next;
		  }
		  ListNode huanStartNode = a;
		  return huanStartNode;
	} catch (NullPointerException e) {
		  return null;
	}
}