数据结构 ——— 单链表oj题：环状链表（判断链表是否带环）

题目要求

手搓简易环状单链表

代码实现

[问题1：slow 指针和 fast 指针一定会相遇吗](#问题1：slow 指针和 fast 指针一定会相遇吗)

[问题2：slow 每次走一步，fast 每次走 n 步是否还能判断链表带环？（n > 2）](#问题2：slow 每次走一步，fast 每次走 n 步是否还能判断链表带环？（n > 2）)

题目要求

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环，返回 true，否则返回 false

手搓简易环状单链表

代码演示：

struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
assert(n1);
struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
assert(n2);
struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
assert(n3);
struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
assert(n4);

n1->val = 3;
n2->val = 2;
n3->val = 0;
n4->val = -4;

n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = n2;

代码实现

代码演示：

bool hasCycle(struct ListNode* head)
{
	struct ListNode* slow = head;
	struct ListNode* fast = head;

	while (fast != NULL && fast->next != NULL)
	{
		slow = slow->next;
		fast = fast->next->next;

		if (slow == fast)
			return true;
	}

	return false;
}

代码解析：

利用快慢指针的思路解决，slow 指针一次走一步，fast 指针一次走两步，当 slow 指针的地址和 fast 指针的地址相同时，就说明链表是环状链表，否则 fast 指针就会走到 NULL

代码验证：

是环状链表时：

不是环状链表时：

问题1：slow 指针和 fast 指针一定会相遇吗

解答：

在 slow 指针一次走一步，fast 指针一次走两步的情况下，一定会相遇

fast 会先进入环中，slow会后进入，假设 slow 进入环后，fast 和 slow 的距离为 N

那么 fast 每走两步，slow 每走一步，距离 N 就会递减 1

N 的值一直递减 1 ，直到最后 N 的长度为 3......2......1......0

当 N 的长度为 0 时，就说明 slow 和 fast 指针相遇了

且 N 为正整数，那么只要是递减 1 ，就一定会递减到 0，所以 slow 和 fast 就一定会相遇

问题2：slow 每次走一步，fast 每次走 n 步是否还能判断链表带环？（n > 2）

解答：

当 slow 每次走一步，fast 每次走 3 步时，不一定会相遇

fast 会先进入环中，slow会后进入，假设 slow 进入环后，fast 和 slow 的距离为 N

那么 slow 每次走一步，fast 每次走 3 步，他们的距离就会缩小 2

也就是 N 的值一直递减 2，就会出现两种情况

情况1：当 N 为偶数时，每次递减2，直到最后 N 的长度为 4......2...... 0（会相遇）

情况2：当 N 为奇数时，每次递减2，直到最后 N 的长度为 3......1......-1（会错过）

且错过后，假设环的长度为 C ，那么 fast 和 slow 的距离就是 C - 1

那么此时当 C-1 为偶数时，fast 和 slow 就会相遇，否则就永远都不会相遇

当 fast 每次走 4 步时也是一样的，假设 slow 进环后，距离为 N

slow 每走一步，fast 每走 4 步，就会缩小 3 步

那么只有当 N 的值是 3 的倍数时，slow 和 fast 才会相遇，其他情况就不会相遇