Floyd 判圈算法(Floyd Cycle Detection Algorithm)

1. 前言

Floyd判圈算法属于对指针操作的算法，它一般需要且仅需要两个指针，通过设定不同的指针移动速度，来判定链表或有限状态机中是否存在环。人为规定移动较快的指针称为快速指针(fast pointer)，移动较慢的指针称作慢速指针(slow pointer)，快速指针比慢速指针移动速度快2倍。

2. 链表中环判定

在判定链表中是否存在环过程中，快慢指针可能会出现下列两种情形之一：

a) 快速指针指向到达链表的结尾 (fast pointer =NULL)，此种情况表明链表中不存在环。这里需要说明的是，快速指针一定先于慢速指针道道链表的尾部。

b) 快速指针在遍历过程中，赶上慢速指针，并且与慢速指针相会和。这种情况下表明链表中存在着环(Loop)。

具体看一个例子，显而易见，链表中存在一个环，环的起点为5,应用快慢指针对此链表进行遍历，并判断其是否存在环。

第一步，建立快慢指针两个变量，并且令快慢指针均指向头节点，准备开始以不同的速度进行移动指针，观察会出现上述提到的哪类情形。

令快指针以两倍于慢指针的速度向前移动

显而易见，当移动至第七个元素的时候，快指针赶上慢指针，在此处快慢指针相遇。符合第二类情形，所以判定链表中存在着环。

3. 算法逻辑

如果存在环，那么快慢指针一定在某处相遇，那究竟是为什么呢？ 借助相关图示进行数学分析和理解，

上图中，采用链表两个节点之间的数目来代表距离

X-代表头节点(Head)到 环起点 之间的距离(Loop start point)

Y-代表环起点(Loop start point)和两指针的第一次相遇点(Meet point)之间的距离

C-代表环的周长/距离

当快慢指针在相遇的时候，分别求出快慢指针移动的相应距离，慢指针移动的距离：
$$Distance\_slow=X+Y+s\ast C;s\in non-negativeinteger(非负整数)$$

与之对应的是快指针移动的距离：
$$Distance\_fast=X+Y+f\ast C;f\in non-negativeinteger(非负整数)$$
在相同移动次数的前提下，快指针移动的距离为慢指针移动距离的两倍，利用此条件可以对上面的距离建立有效的关系式。
$$Distance\_fast=2\ast Distance\_slow$$
通过等式变换和合并同类项后，我们可以得到，
$$X+Y+f\ast C=2\ast (X+Y+s\ast C)$$

$$X+Y=f\ast C-2\ast s\ast C=(f-2\ast s)\ast C=K\ast C$$

通过简化上面的关系是，最终我们可以得到两个简单的关系式：

X+Y=K*C----(1)

X=K*C-Y----(2)

上面关系式为寻找环的起点提供了方向和思路，如果两个指针相遇后，把头节点赋给慢指针，快指针的位置保持不变，我们以每次步长为1进行移动，快慢指针最后将相遇在环的起点位置（Loop start point)。此时慢指针走过的距离为X，快指针走过的距离为K*C-Y=X。

4. 算法实现

a) 头文件声明函数， make_node 函数从整数创建待插入的结点；insert_node 利用头插法，插入结点，头结点一直在第一个位置。is_contain_loop函数判定链表中是否存在环，find_loop_start_point函数找到环的起始结点。

/**
 * @file floyd_cycle_detecion.h
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-06-18
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef FLOYD_CYCLE_DETECTION_H
#define FLOYD_CYCLE_DETECTION_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct node
{
    int data;
    struct node *next;
}node,*node_link;


void make_node(node_link *new_node, int new_value);

void insert_node(node_link *head,int new_value);

bool is_contain_loop(node_link *head);

node_link find_loop_start_point(node_link *head);


#endif

b) 函数定义

值得一提的是，快指针采用 fast_pointer=fast_pointer->next->next方式实现跨越式移动。

/**
 * @file floyd_cycle_detecion.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-06-18
 * 
 * @copyright Copyright (c) 2023
 * 
 */

#ifndef FLOYD_CYCLE_DETECTION_C
#define FLOYD_CYCLE_DETECTION_C
#include "floyd_cycle_detection.h"

void make_node(node_link *new_node, int new_value)
{
    *new_node=(node_link)malloc(sizeof(node));
    (*new_node)->data=new_value;
    (*new_node)->next=NULL;

    return;
}

void insert_node(node_link *head, int new_value)
{
    node_link new_node;

    make_node(&new_node,new_value);

    if((*head)==NULL)
    {
        *head=new_node;
    }
    else //insert before the current node
    {
        new_node->next=*head;
        *head=new_node;
    }

    return;
}

bool is_contain_loop(node_link *head)
{
    node_link slow_pointer;
    node_link fast_pointer;

    slow_pointer=fast_pointer=*head;

    while(slow_pointer && fast_pointer && fast_pointer->next)
    {
        slow_pointer=slow_pointer->next;
        fast_pointer=fast_pointer->next->next;

        if(slow_pointer==fast_pointer)
        {
            return true;
        }
    }

    return false;
}

node_link find_loop_start_point(node_link *head)
{
    node_link slow_pointer;
    node_link fast_pointer;

    slow_pointer = fast_pointer = *head;

    while (slow_pointer && fast_pointer && fast_pointer->next)
    {
        slow_pointer = slow_pointer->next;
        fast_pointer = fast_pointer->next->next;

        if (slow_pointer == fast_pointer)
        {
            break;
        }
    }

    if(slow_pointer!=fast_pointer)
    {
        return NULL;
    }

    slow_pointer=*head;

    while(slow_pointer!=fast_pointer)
    {
        slow_pointer=slow_pointer->next;
        fast_pointer=fast_pointer->next;
    }

    return slow_pointer;
}

#endif

c) 测试函数

通过临时结点temp_node_1和temp_node_2在链表内创建一个环，方便后面的相关测试。

/**
 * @file floyd_cycle_detetcion_main.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-06-18
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef FLOYD_CYCLE_DETECTION_MAIN_C
#define FLOYD_CYCLE_DETECTION_MAIN_C
#include "floyd_cycle_detection.c"

int main(void)
{
    int i;
    int arr[]={10,9,8,7,6,5,4,3,2,1};
    int n=sizeof(arr)/sizeof(int);

    node_link head=NULL;
    node_link temp_node_1;
    node_link temp_node_2;
    node_link loop_start_point;
    bool res;

    for(i=0;i<n;i++)
    {
        insert_node(&head,arr[i]);
    }

    temp_node_1=head;

    while(temp_node_1 && temp_node_1->data!=5)
    {
        temp_node_1=temp_node_1->next;
    }

    temp_node_2=temp_node_1;

    while(temp_node_2->next!=NULL)
    {
        temp_node_2=temp_node_2->next;
    }

    temp_node_2->next=temp_node_1;

    res=is_contain_loop(&head);

    if(res)
    {
        printf("there is a loop inside\n");
    }
    else
    {
        printf("there is no a loop inside\n");
    }

    loop_start_point=find_loop_start_point(&head);

    printf("The loop start point had been detected\n");
    getchar();

    return EXIT_SUCCESS;
}



#endif

5. 小结

本文通过学习Floyd判圈算法，对快慢指针有了更加深入的理解，希望今后能更加数量运用快慢指针的思想，分析解决不同的实际问题。

参考资料：

tf(“there is no a loop inside\n”);
}

loop_start_point=find_loop_start_point(&head);

printf("The loop start point had been detected\n");
getchar();

return EXIT_SUCCESS;

}

#endif

5. 小结

本文通过学习Floyd判圈算法，对快慢指针有了更加深入的理解，希望今后能更加数量运用快慢指针的思想，分析解决不同的实际问题。



参考资料：

1.[Floyd’s Cycle Finding Algorithm - GeeksforGeeks](https://www.geeksforgeeks.org/floyds-cycle-finding-algorithm/)