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

问题描述

给定一个链表，判断它是否有环。链表是一种数据结构，它由一系列的节点组成，每个节点包含一个值和一个指向下一个节点的指针。如果一个链表的最后一个节点的指针指向了链表中的某个节点，就形成了一个环。例如，1 -> 2 -> 3 -> 4 -> 5 -> 2就是一个有环的链表，而1 -> 2 -> 3 -> 4 -> 5 -> NULL就是一个无环的链表。

解决方案

这个问题可以用快慢指针的方法来解决。快慢指针是一种双指针的变种，它可以用两个变量来表示链表中的两个节点，一个快指针每次移动两个节点，一个慢指针每次移动一个节点。然后，我们让这两个指针同时从链表的头部开始移动，如果链表有环，那么快指针一定会追上慢指针，也就是说，它们会在某个节点相遇。如果链表无环，那么快指针一定会先到达链表的尾部，也就是说，它会遇到NULL。这个算法的时间复杂度是O(n)，空间复杂度是O(1)，其中n是链表的长度。

代码

以下是用C语言实现的代码，假设链表的节点的结构体已经定义好。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// 定义一个链表的节点的结构体，包含一个值和一个指向下一个节点的指针
struct list_node {
    int value;
    struct list_node *next;
};

// 定义一个函数，判断一个链表是否有环，返回一个布尔值
bool has_cycle(struct list_node *head) {
    // 如果链表为空或只有一个节点，返回false
    if (head == NULL || head->next == NULL) {
        return false;
    }
    // 定义两个指针，一个快指针，一个慢指针，初始都指向链表的头部
    struct list_node *fast = head;
    struct list_node *slow = head;
    // 循环，直到快指针到达链表的尾部或者快慢指针相遇
    while (fast != NULL && fast->next != NULL) {
        // 快指针每次移动两个节点
        fast = fast->next->next;
        // 慢指针每次移动一个节点
        slow = slow->next;
        // 如果快慢指针相遇，说明链表有环，返回true
        if (fast == slow) {
            return true;
        }
    }
    // 如果快指针到达链表的尾部，说明链表无环，返回false
    return false;
}

// 定义一个函数，创建一个有环的链表，用于测试
struct list_node *create_cycle_list(int *array, int size, int pos) {
    // 如果数组为空或长度为0，返回NULL
    if (array == NULL || size == 0) {
        return NULL;
    }
    // 创建一个虚拟的头节点，用于方便操作
    struct list_node *dummy = (struct list_node *)malloc(sizeof(struct list_node));
    dummy->value = 0;
    dummy->next = NULL;
    // 定义一个指针，指向当前的节点
    struct list_node *curr = dummy;
    // 定义一个指针，指向环的入口节点，初始为NULL
    struct list_node *entry = NULL;
    // 遍历数组，创建链表的节点
    for (int i = 0; i < size; i++) {
        // 创建一个新的节点，赋值为数组的元素
        struct list_node *node = (struct list_node *)malloc(sizeof(struct list_node));
        node->value = array[i];
        node->next = NULL;
        // 把新的节点连接到当前的节点的后面
        curr->next = node;
        // 更新当前的节点为新的节点
        curr = curr->next;
        // 如果当前的节点的下标等于环的位置，记录环的入口节点
        if (i == pos) {
            entry = curr;
        }
    }
    // 如果环的入口节点不为NULL，把链表的尾部节点的指针指向环的入口节点，形成环
    if (entry != NULL) {
        curr->next = entry;
    }
    // 返回链表的真正的头部节点
    return dummy->next;
}

// 定义一个函数，打印一个链表
void print_list(struct list_node *head) {
    // 定义一个计数器，记录打印的节点的个数，用于防止无限循环
    int count = 0;
    // 定义一个指针，指向当前的节点
    struct list_node *curr = head;
    // 打印[
    printf("[");
    // 循环，直到当前的节点为NULL或者打印的节点超过100个
    while (curr != NULL && count < 100) {
        // 打印当前节点的值
        printf("%d", curr->value);
        // 如果当前节点不是最后一个节点，打印,
        if (curr->next != NULL) {
            printf(", ");
        }
        // 更新当前节点为下一个节点
        curr = curr->next;
        // 增加计数器
        count++;
    }
    // 如果打印的节点超过100个，说明链表有环，打印...
    if (count == 100) {
        printf("...");
    }
    // 打印]
    printf("]\n");
}

// 定义一个函数，释放一个链表占用的内存，假设链表无环
void free_list(struct list_node *head) {
    // 定义一个指针，指向当前的节点
    struct list_node *curr = head;
    // 循环，直到当前的节点为NULL
    while (curr != NULL) {
        // 定义一个临时的指针，指向当前的节点
        struct list_node *temp = curr;
        // 更新当前节点为下一个节点
        curr = curr->next;
        // 释放临时指针指向的节点
        free(temp);
    }
}

// 定义一个主函数，测试上述函数
int main() {
    // 定义一个测试用的数组和环的位置
    int array[] = {1, 2, 3, 4, 5};
    int size = sizeof(array) / sizeof(array[0]);
    int pos = 1;
    // 创建一个有环的链表
    struct list_node *head = create_cycle_list(array, size, pos);
    // 打印链表
    printf("链表：");
    print_list(head);
    // 调用判断是否有环的函数，得到结果
    bool result = has_cycle(head);
    // 打印结果
    printf("结果：%s\n", result ? "有环" : "无环");
    // 释放链表占用的内存，因为链表有环，所以不能用free_list函数，只能手动释放
    free(head->next->next->next->next);
    free(head->next->next->next);
    free(head->next->next);
    free(head->next);
    free(head);
    // 返回0，表示程序正常结束
    return 0;
}

运行结果

总结

这个问题的核心是如何在不知道链表的长度的情况下，判断链表是否有环。如果用暴力的方法，就需要用一个额外的数据结构，比如数组或哈希表，来存储遍历过的节点，然后判断当前的节点是否已经存在于这个数据结构中，时间复杂度是O(n)，空间复杂度也是O(n)。如果用快慢指针的方法，就可以在不使用额外的空间的情况下，判断链表是否有环。如果用快慢指针的方法，就可以在O(1)的空间复杂度下，完成这个任务。快慢指针的原理是，如果链表有环，那么快指针一定会追上慢指针，如果链表无环，那么快指针一定会先到达链表的尾部。