【leetcode】Linked List Cycle I & II

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

Can you solve it without using extra space?

 

每个节点再开辟一个属性存放是否访问过，这样遍历一遍即可知道是否有环。

但为了不增加额外的空间，

可以设置两个指针，一个一次走一步，另一个一次走两步，如果有环则两个指针一定会再次相遇，反之则不会。

 

C++:

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head==NULL||head->next==NULL) return 0;

        ListNode *p=head;
        ListNode *q=head;
        int flag=0;
        while(p->next)
        {
            if(p->next==q)
            {
                flag=1;
                break;
            }
            p=p->next;
            if(p->next==NULL)
                break;
            p=p->next;
            q=q->next;
        }
        if(flag==1)
            return 1;
        else
            return 0;
    }
};

 

Python：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # @param head, a ListNode
    # @return a boolean
    def hasCycle(self, head):
        if head is None:
            return False
        p1=head
        p2=head
        while True:
            if p1.next is not None:
                p1=p1.next.next
                p2=p2.next
                if p1 is None or p2 is None:
                    return False
                elif p1==p2:
                    return True
            else:
                return False
        return False

 

II：

 

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

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

 

当fast与slow相遇时，

slow肯定没有遍历完链表，而fast已经在环内循环了$n$圈($1 \leq n$)。假设slow走了$s$步，则fast走了$2s$步（fast步数还等于$s$加上在环上多转的$n$圈），设环长为$r$，则：

2s=s+nr

s=nr

设整个链表长$L$，环入口点与相遇点距离为$a$，起点到环入口点的距离为$x$，则

x+ax=nr=(n–1)r+r=(n−1)r+L–x

x=(n−1)r+(L–x–a)

$L – x – a$为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于$n-1$圈内环+相遇点到环入口点，

于是我们可以从{head}开始另设一个指针{slow2}，两个慢指针每次前进一步，它俩一定会在环入口点相遇。

分析来自 ACM之家。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head==NULL||head->next==NULL) return NULL;
        ListNode *p=head;
        ListNode *q=head;
        while(p->next&&p->next->next)
        {
            q=q->next;
            p=p->next->next;
            if(q==p)
            {
                q=head;
                while(q!=p)
                {
                    p=p->next;
                    q=q->next;
                }
                
                return q;
            }
        }
        
        return NULL;
    }
};