欢迎来到 Claffic 的博客 💞💞💞
前言：
快慢指针指的是每次指针移动的步长，是解决链表相关的题目的一大利器，下面我将以例题的形式讲解快慢指针法。
目录
一. 链表的中间结点
思路：
代码实现：
二. 链表中倒数第k个结点
思路：
代码实现：
三. 判断链表中是否有环
思路：
代码实现：
四. 返回链表入环的第一个结点
思路：
代码实现：
一. 链表的中间结点
点我做题
思路：
创建两个快慢指针 slow , fast ，起始共同指向头节点，slow 每次走一步，fast 每次走两步，当 fast 为空或 fast 的下一个结点为空时，slow 即是中间节点的位置。
解释：
由于 fast 每次走两步，slow 每次走一步，slow 总是落后 fast 整体一半的长度最终 slow 理应为中间结点。
结点数为奇数：
最终 fast 在最后一个结点，此时结束的标志为 fast->next == NULL；
结点数为偶数：
最终 fast 在最后一个结点的下一个指向，此时的结束标志为 fast == NULL;
代码实现：
struct ListNode* middleNode(struct ListNode* head){
struct ListNode* slow,*fast;
slow = head;
fast = head;
while(fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
return slow;
}二. 链表中倒数第k个结点
点我做题
思路：
同样，创建两个快慢指针 slow , fast ，起始共同指向头节点，先让 fast 走 k 步，再让 fast 和 slow 同时前进，直到 fast 为空为止。
解释：
先让 fast 走 k 步，那么 fast 与 slow 之间就隔了 k-1 个结点，fast 与 slow 同时前进，直到 fast 为空时，fast 与 slow 之间依然隔 k-1 个结点，那就是倒数第 k 个结点。
代码实现：
int kthToLast(struct ListNode* head, int k){
struct ListNode* fast,*slow;
fast = slow = head;
if(head == NULL)
{
return NULL;
}
//fast 前进 k 步
while(k--)
{
fast = fast->next;
}
//slow 与 fast 共同前进
while(fast)
{
slow = slow->next;
fast = fast->next;
}
//注意返回的是整型数值
return slow->val;
}三. 判断链表中是否有环
点我做题
思路：
快慢指针 slow , fast，都从 head 开始，slow 一次走一步，fast 一次走两步，如果 slow 和 fast 能相遇，则链表有环。
解释：
主要是证明 有环情况下两个指针一定能相遇：
fast 比 slow 先进入环，如图，假设 slow 和 fast 的位置，这两个指针之间差 N 步，
由于 fast 每次走两步，slow 每次走一步，所以 slow 和 fast 之间的距离每次缩短 1
N - 1
N - 2
N - 3
...
2
1
0 //此时两者相遇
证毕。
代码实现：
bool hasCycle(struct ListNode* head) {
struct ListNode* fast,*slow;
fast = slow = head;
while(fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(fast == slow)
{
return true;
}
}
return false;
} 四. 返回链表入环的第一个结点
点我做题
思路：
这里要先放一个结论：
在链表有环的情况下，一个指针在起始结点开始走，另一个结点在相遇点开始走，最终两个指针会在入环点相遇。
快慢指针 slow , fast，都从 head 开始，slow 一次走一步，fast 一次走两步，找到相遇点后，再让 start 与 meet 同时前进，两者相等的点即是入环点。
解释：
自然要证明上边的结论：
在这里，我们设几个常量：
L：起始点到入环点的距离；
X：入环点到相遇点的距离；
C：环的周长。
已知条件：
slow 走的距离：L + X ；
fast 走的距离：L + n*C + X (n >=1) ；
fast 走的长度是 slow 走的长度的 2 倍。
推导：
fast 走的长度是 slow 走的长度的 2 倍 -->
2*(L + X) == L + n*C + X (n >=1)，
整理得：L == C - X + (n - 1)*C (n >=1).
对 L == C - X + (n - 1)*C (n >=1) 的解释：
C - X + (n - 1)*C (n >=1) 原本是 meet 到 innode 要走的所有可能距离，
而 L == C - X + (n - 1)*C (n >=1) ，说明 start 到 innode 要走的距离与 meet 到 innode 要走的所有可能距离相等，所以两者相遇的点一定是 innode.
代码实现：
struct ListNode* detectCycle(struct ListNode *head) {
struct ListNode* slow,*fast;
slow = fast = head;
while(fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
{
struct ListNode* meet = slow;
struct ListNode* start = head;
while(meet != start)
{
meet = meet->next;
start = start->next;
}
return meet;
}
}
return NULL;
}总结：
快慢指针是解决链表问题的一大利器，建议多画图理解掌握。
码文不易
如果你觉得这篇文章还不错并且对你有帮助，不妨支持一波哦 💗💗💗
