Question

How to find the beginning node of a loop in a given linked list ? Let’s call this the cycle point

So far, I’ve understand the following (using slow/fast pointer):

1. Assume list has a non-looped part of size k
2. slow moves k steps
3. fast moves 2k steps
4. fast is (2k – k)= k steps ahead of slow
5. slow is at the beginning of loop; also known as Cycle point
6. fast is (LOOP_LENGTH - k) steps behind from Cycle point or slow pointer at this point
7. for each 1 step slow moves, fast moves 2 steps and gains on slow by 1 step.
8. Thus, it would take fast (LOOP_LENGTH - k) steps to meet slow and collide
9. This is the step I don’t understand:
   At this collision point, both nodes will be k steps from the front of the loop.
10. Once the collision point is found, move one pointer to the head of list.
11. Now move both pointers at the speed of 1 step / turn till the collide. The node at which they both meet is the beginning of the the loop and hence the Cycle point

Can someone please explain me step 9 and after that ?

Thanks

EDIT:

One thing I’d like to point out is, once inside the loop, fast will never overtake slow pointer. They will collide. Here’s why: slow is at i and fast is assuming at i-1. when they move, slow=> i+1 and fast will be at i+1 too, hence collision. OR, slow is at i and fast is at i-2. next move, slow-> i+1; fast: i. next move, slow-> i+2, fast: i+2 and hence collision again. so fast will never be able to overtake slow, only collide once inside the loop!

Answer 1

Your 6. is wrong, the fast pointer is still k steps away from the slow pointer which is at the cycle point at that time; but better use ahead or behind instead of away. Plus, k may be smaller, bigger, or equal to the loop_length.

So, the fast pointer is k steps ahead of a slow one when that’s reached the loop point which is, at your supposition, k steps after the start. Now, measuring on a loop, the fast pointer is k % loop_length steps ahead of the loop point. Right? If k = some_n * loop_length + r, the fast pointer is r steps ahead of the loop point, which is to say, r := k % loop_length steps ahead.

But that means that the slow pointer is loop_length - r steps ahead of the fast one, along the loop. This is a loop after all. So after loop_length - r additional steps the fast pointer will catch on to the slow one. For each step the slow pointer moves away, the fast moves closer in by two steps.

So we don’t know k, we don’t know loop_length or r, we only know m = k + loop_length - r = some_n * loop_length + r + loop_length - r = (some_n+1) * loop_length. The total number of steps m until the two pointers’ meeting point, is a multiple of the loop length.

So now we start over, with a new pointer at the start and the slow where it met the fast, m steps ahead of the new. We move the new and the slow at equal speed, by 1 step at each time, and at the cycle point they shall meet – because when the new pointer has reached the cycle point, the second is still m steps ahead, which is to say, m % loop_length == 0 steps ahead along the loop. That way we find out what k is (we count our steps all the time), and the cycle point.

And we find loop_length by going along the loop one more time, until the two meet one more time.

• see also: http://en.wikipedia.org/wiki/Cycle_detection#Algorithms