LeetCode 141 Linked List Cycle(循环链表)(HashSet/Linked List)

翻译

给定一个链表,判断是否有一个循环在其中。

跟进:
你可以不用额外的空间来解决这个问题吗?

原文

Given a linked list, determine if it has a cycle in it.

Follow up:
Can you solve it without using extra space?

分析

解决方案 1 哈希表

有个效率不太高的方法,那就是在遍历这个链表的时候看看是否有某个节点曾近访问过。

这就用到了哈希的思想,不论是用map,还是set,甚至是vector,都是可以的。

下面的代码以set为例,如果visited中还没有包含这个节点,就将它添加到visited中。否则,就表示它已经访问过了,这也意味着这里存在一个循环。

bool hasCycle(ListNode *head) {
    set<ListNode*> visited;
    set<ListNode*>::iterator iter;    
    while (head != NULL) {
        iter = visited.find(head);
        if (iter == visited.end()) {
            visited.insert(head);
        } else {
            return true;
        }
        head = head->next;
    }
    return false;
}
updated at 2016/09/20
    public boolean hasCycle(ListNode head) {
        HashSet<ListNode> visited = new HashSet<>();
        while (head != null) {
            if (visited.contains(head)) {
                return true;
            } else {
                visited.add(head);
            }
            head = head.next;
        }
        return false;
    }

哈希表方法的效率:

时间复杂度: O(n)

空间复杂度: O(n)

但是题目的有个更高的要求,那就是不用额外的空间,那么接下来我们就来看另一种方法。

解决方案 2 双指针

想象1,在一条直线的公路上,在速度保持稳定不变的情况下,有着更快的汽车和慢些的自行车,汽车在前,自行车在后,他们肯定是不可能的汇合的。

ListNode *bicycle = head;
ListNode *car = head->next;
while (bicycle != car) { 
// other code
}

之所以要一前一后,只是为了排除一开始就是汇合的情况。当然,如果一开始是同一起点,那就要在开始while循环之前,先让他们动起来。

ListNode *bicycle = head;
ListNode *car = head;
bicycle = bicycle->next;
car = car->next->next;
while (bicycle != car) {
// other code
}

想象2,如果是在一个包含循环的公路上,也就是一直往前行驶着,但终究会回到之前走过的某个路段上。至于在这种公路上,他们为什么会汇合。我们在汇合的那一刻,把时间禁止,再回退。假设此时自行车离刚才设定的汇合点距离是S,汽车离该汇合点距离是2S,但自行车行驶这距离S的路段需要10分钟,而汽车行驶这距离2S的路段也是10分钟,那么10分钟他们不就相遇了吗?(别问我为什么汽车的速度只比自行车快1倍……

ListNode *bicycle = head;
ListNode *car = head->next;
while (bicycle != car) {
   if (car == NULL || car->next == NULL)
      return false;
   bicycle = bicycle->next;
   car = car->next->next;
}

这个双指针法的效率:

空间复杂度:

如果没有循环,那么结束的条件是汽车走完全程,这就取决于路程的长短了。所以是 O(n)
如果有循环,需要分开来看:设非循环的长度为N,循环的长度为M,非循环的路程显然都只用走一次,循环的路程可能要走K次。因此也就是 O(N) + O(kM) ,虽然并不能知道k是多少,但走的总路程肯定还是可以用 tn 来计。t为常亮,n为N和M之和。所以时间复杂度仍然是 O(n)

空间复杂度:

这个就很明显的,就是 O(1) ,原文只使用了2个指针节点,也就是个数为常量。

代码

C Plus Plus

bool hasCycle(ListNode *head) {
    if (head == NULL || head->next == NULL)
        return false;
    ListNode *bicycle = head;
    ListNode *car = head->next;
    while (bicycle != car) {
        if (car == NULL || car->next == NULL)
            return false;
        bicycle = bicycle->next;
        car = car->next->next;
    }
    return true;
}

Java

update 2016/09/20
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null)
            return false;
        ListNode bicycle = head;
        ListNode car = head.next;
        while (bicycle != car) {
            if (car == null || car.next == null)
                return false;
            bicycle = bicycle.next;
            car = car.next.next;
        }
        return true;
    }
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页