经典算法题 -- 判断单链表是否成环及寻找成环节点

引言

判断单链表是否成环是一个计算机领域的经典算法问题

如何通过程序判断传入的链表是否存在环，并且求出环长度、成环点等问题

下面就是一个存在环的单链表

基本算法 -- hash

最简单的方法是创建一个哈希表，将每个节点的地址都存储起来，如果某个节点的地址出现在了哈希表中，那么首次出现的那个节点就是我们要找的成环的起点了

1）代码示例

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


def get_start_cycle(pHead):
    nodedict = {}
    while pHead is not None:
        if nodedict.get(pHead) is not None:
            return pHead
        nodedict[pHead] = 1
        pHead = pHead.next
    return None

2）时间空间复杂度

显然，在最坏情况下，需要遍历整个链表，所以时间复杂度为 O(N)，空间复杂度为 O(N)

改进算法 -- 龟兔赛跑

有过一定生活经验的人马上就会想到，在操场的圆形赛道上跑步与在街道上跑马拉松有什么不同，那就是在操场的赛道上，跑得快的人会从后面追上跑得慢的人

那么，对于单链表来说，我们就可以用两个指针，一个快指针，一个慢指针，从起点出发，快指针如果在出发后追上了慢指针，那就说明单链表是存在环的

1）步长选取

那么快指针要选取多大的步长呢？答案是 2，如果选取大于 2 的步长，就会出现快指针直接越过慢指针的情况

代码示例

typedef struct LinkedNode {
    int val;
    LinkedNode *next;
} LinkedNode;

int is_cycle(LinkedNode *head) {
    if (head == NULL || head->next == NULL) {
        return 0;
    }
    LinkedNode *slow = head->next, *quick = head->next->next;
    while (quick != NULL && quick->next != NULL) {
        if (quick == slow) {
            return 1;
        }
        quick = quick->next->next;
        slow = slow->next;
    }
    return 0;
}

时间空间复杂度

因为快指针绕一圈，慢指针只能绕半圈，所以我们可以得出两指针相遇时，慢指针一定没有绕满一圈

而不成环的情况下，快指针一定先到达终点，所以时间复杂度为 O(n)

整个过程没有额外分配空间，所以空间复杂度是 O(1)

如何通过龟兔赛跑法求出成环点

原理推导

假设环长为 d，初始距入口点为 n，入口点距相遇点为 m

假设此时快指针已经绕了 k 圈，那么我们可以得到公式：

m+n = k*d

但是，我们要求的是入口点距起始点的距离 m，所以我们需要进行移项：

m = k*d-n

因为两指针相遇时，快指针一定至少已经绕满一圈，所以 k 一定大于等于 1，而 d - n 就是从相遇点继续前进到起始点的距离，所以我们可以进一步分解 k*d：

m = (k-1)*d + (d-n)

因此，我们可以发现，从起始点出发到成环点的距离与相遇点出发到成环点的距离之间只差 (k-1) 个

也就是说，两个指针如果以相同步长分别从起始点与相遇点出发，相遇时一定在成环点

代码示例

LinkedNode *get_cycle_start_node(LinkedNode *head) {
    if (head == NULL || head->next == NULL) {
        return NULL;
    }
    LinkedNode *slow = head->next, *quick = head->next->next;
    while (quick != NULL && quick->next != NULL) {
        if (quick == slow) {
            quick = head;
            while (slow != quick) {
                slow = slow->next;
                quick = quick->next;
            }
            return slow;
        }
        quick = quick->next->next;
        slow = slow->next;
    }
    return NULL;
}

时间空间复杂度

 

我们看到，无论自相遇点出发的指针绕环多少圈，自起始点出发的指针最多遍历 n-1 个元素，所以其时间复杂度也是 O(n) 的，而空间复杂度为 O(1)

 

找出成环点的另一个思路 -- 断链法

三十六计里有一计 -- 过河拆桥

在已知单链表成环的前提下，我们每走一步都把前面的路拆掉，那么当我们发现无路可走时，那就说明我们又回到了原来的路上，那个点自然就是成环点了

 

代码示例

#include <stdio.h>
#include <malloc.h>

#define null NULL

typedef struct LinkedNode {
    int val;
    LinkedNode *next;
} LinkedNode;

int is_cycle(LinkedNode *head) {
    if (head == null || head->next == null) {
        return 0;
    }
    LinkedNode *slow = head->next, *quick = head->next->next;
    while (quick != null && quick->next != null) {
        if (quick == slow) {
            return 1;
        }
        quick = quick->next->next;
        slow = slow->next;
    }
    return 0;
}

LinkedNode *get_cycle_start_node(LinkedNode *head) {
    if (!is_cycle(head)) {
        return null;
    }
    while (head->next != null) {
        LinkedNode *temp = head->next;
        head->next = null;
        head = temp;
    }
    return head;
}

 

 

 

时间空间复杂度

 

这个算法先判断是否成环，后从头到尾最多遍历 n-1 个元素，所以时间复杂度也是 O(n)，而空间复杂度为 O(1)