判断链表是否有环：C++实现详解

判断链表是否有环：C++实现详解

在C++面试中，判断链表是否有环是一个常见的面试题目。这个问题不仅考察候选人的编程能力，还考察他们对数据结构和算法的理解。本文将详细介绍如何编写一个函数来判断一个链表是否有环，并提供多种实现方法，包括哈希表法和快慢指针法。

链表节点定义

首先，我们需要定义一个链表节点类，用于表示链表中的每个节点。

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

方法一：哈希表法

哈希表法的思路是遍历链表，并将每个节点存储在一个哈希表中。如果在遍历过程中发现某个节点已经存在于哈希表中，则说明链表存在环。

#include <unordered_set>

bool hasCycleHash(ListNode* head) {
    std::unordered_set<ListNode*> nodes_seen;
    while (head != nullptr) {
        if (nodes_seen.find(head) != nodes_seen.end()) {
            return true;
        }
        nodes_seen.insert(head);
        head = head->next;
    }
    return false;
}

这种方法的时间复杂度为O(n)，空间复杂度也为O(n)，因为需要额外的空间来存储节点。

方法二：快慢指针法

快慢指针法（也称为龟兔赛跑算法）是判断链表是否有环的经典方法。我们使用两个指针，一个快指针每次移动两步，一个慢指针每次移动一步。如果链表中存在环，快指针最终会追上慢指针；如果不存在环，快指针会先到达链表的末尾。

bool hasCycleTwoPointers(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return false;
    }

    ListNode* slow = head;
    ListNode* fast = head->next;

    while (slow != fast) {
        if (fast == nullptr || fast->next == nullptr) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }

    return true;
}

这种方法的时间复杂度为O(n)，空间复杂度为O(1)，因为只使用了常数级别的额外空间。

方法三：修改链表结构法

这种方法通过修改链表结构来判断是否有环。我们可以在遍历链表时，将每个节点的指针指向一个特殊的标记节点。如果在遍历过程中发现某个节点的指针已经指向了这个标记节点，则说明链表存在环。

bool hasCycleModifyStructure(ListNode* head) {
    ListNode* marker = new ListNode(-1);
    while (head != nullptr) {
        if (head->next == marker) {
            return true;
        }
        ListNode* next_node = head->next;
        head->next = marker;
        head = next_node;
    }
    return false;
}

这种方法的时间复杂度为O(n)，但会破坏链表的结构，不推荐在实际应用中使用。

示例代码

以下是一个完整的示例，展示了如何使用上述方法判断链表是否有环。

#include <iostream>
#include <unordered_set>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

bool hasCycleHash(ListNode* head);
bool hasCycleTwoPointers(ListNode* head);
bool hasCycleModifyStructure(ListNode* head);

int main() {
    // 创建一个有环的链表
    ListNode* node1 = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    ListNode* node4 = new ListNode(4);
    ListNode* node5 = new ListNode(5);

    node1->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = node2;  // 创建环

    std::cout << "Using hash table method: " << (hasCycleHash(node1) ? "Cycle detected" : "No cycle") << std::endl;
    std::cout << "Using two pointers method: " << (hasCycleTwoPointers(node1) ? "Cycle detected" : "No cycle") << std::endl;
    std::cout << "Using modify structure method: " << (hasCycleModifyStructure(node1) ? "Cycle detected" : "No cycle") << std::endl;

    return 0;
}

bool hasCycleHash(ListNode* head) {
    std::unordered_set<ListNode*> nodes_seen;
    while (head != nullptr) {
        if (nodes_seen.find(head) != nodes_seen.end()) {
            return true;
        }
        nodes_seen.insert(head);
        head = head->next;
    }
    return false;
}

bool hasCycleTwoPointers(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return false;
    }

    ListNode* slow = head;
    ListNode* fast = head->next;

    while (slow != fast) {
        if (fast == nullptr || fast->next == nullptr) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }

    return true;
}

bool hasCycleModifyStructure(ListNode* head) {
    ListNode* marker = new ListNode(-1);
    while (head != nullptr) {
        if (head->next == marker) {
            return true;
        }
        ListNode* next_node = head->next;
        head->next = marker;
        head = next_node;
    }
    return false;
}

总结

判断链表是否有环是一个经典的面试题目，通过本文的介绍，我们了解了三种常见的解决方法：哈希表法、快慢指针法和修改链表结构法。每种方法都有其优缺点，快慢指针法由于其时间复杂度和空间复杂度的优势，是最常用的方法。

希望这些内容对你理解和实现链表环检测有所帮助。如果你有任何问题或需要进一步的指导，请随时联系我！