Another way to go around this would be to initialize slow and fast to different nodes(1st and 2nd for example) at the beginning. That way the cycle will still be detected but the loop_node will never be head, but now the nodes must be counted(method 2) to break the cycle.

You're welcome Tran Duc!

powerpoint.

Thanks Soumava Nag :)

cannot, the equation doesn't work for 3x.

Can find the loop....but loop removal can't use the formula...

you are wrong

That will work!

ptr2 doesn't need to start inside the loop. In the last step, ptr1 will start at 0 and ptr2 will start at 13. Then, you move both of them until they meet. They will both move 11 steps (ptr2 will make one loop) until they meet at 3.

If it takes K steps for the slow runner to enter the loop, and the fast runner moves at double the pace as the slow runner. Then the fast runner is 2K - K step or K steps into the loop. 1) When the slowRunner is 0 step inside the loop. 2) The fastRunner is K steps into the loop. 3) slowRunner is K steps behind FastRunner. 4) FastRunner is Loop_size - K steps behind slowRunner. So because fastRunner catches up to the slowRunner at a pace of 1 per step. It will take Loop_size - K to catch up to it. so if you have a loop size of 8 and your fastRunner is 3 steps into the loop which = K. And if you traverse the difference (Loop_size-k) of 5 steps to get to where they collide then it means that there are 3 more steps or k steps to the head of the circle. Because K = mod(k, loop_size), this works for any size of loop. And since it took slowRunner k step to get inside of the loop, the collision spot and head of the linked list is K steps away from the beginning of the loop. Then you can move the slow pointer back to the beginning and move step by step to find the head of the loop.

Thanks Kaushal!

Because the equation works for all size of loop. You don't really know where the start of the loop is at that point. You need to find it. Basically, if it takes K steps for the slow runner to enter the loop, and the fast runner moves at double the pace as the slow runner. Then the fast runner is 2K - K step or K steps into the loop. 1) When the slowRunner is 0 step inside the loop. 2) The fastRunner is K steps into the loop. 3) slowRunner is K steps behind FastRunner. 4) FastRunner is Loop_size - K steps behind slowRunner. So because fastRunner catches up to the slowRunner at a pace of 1 per step. It will take Loop_size - K to catch up to it. so if you have a loop size of 8 and your fastRunner is 3 steps into the loop which = K. And if you traverse the difference (Loop_size-k) of 5 steps to get to where they collide then it means that there are 3 more steps or k steps to the head of the circle. Because K = mod(k, loop_size), this works for any size of loop. And since it took slowRunner k step to get inside of the loop, the collision spot and head of the linked list is K steps away from the beginning of the loop. Then you can move the slow pointer back to the beginning and move step by step to find the head of the loop.

Let us say that n=k+b.---(1) and it has already been proved that k+m is a multiple of n. =>(k+m)=a*n---(2) Subtracting two equations, =>m-b=(a-1)*n =>m= b+(a-1)*n Hence it suggests that m is the distance equal to certain number of full iterations in the circle and distance b. hence, they definitely meet.

(k+m) is multiple of n, so k+m=a*n where a is that multiple shifting k to right m=(a*n) - k for simplicity let's see (a*n) as 'n' only m=n-k This (n-k) is the distance between meeting point(k) and start of the cycle .(refer diagram) From this point one went to head. So if ptr1 starts from head and covers 'm' distance, then it's bound to meet ptr2 which starts from that meeting point(k) and reaches start point of cycle.

Thanks Rahul!

Thanks kashish mittal :)

I came here looking for better explanation to this solution but didn't find it. Let me try to explain it to you and maybe I will get it in the process as well. If it takes K steps for the slow runner to enter the loop, and the fast runner moves at double the pace as the slow runner. Then the fast runner is 2K - K step or K steps into the loop. 1) When the slowRunner is 0 step inside the loop. 2) The fastRunner is K steps into the loop. 3) slowRunner is K steps behind FastRunner. 4) FastRunner is Loop_size - K steps behind slowRunner. So because fastRunner catches up to the slowRunner at a pace of 1 per step. It will take Loop_size - K to catch up to it. so if you have a loop size of 8 and your fastRunner is 3 steps into the loop which = K. And if you traverse the difference (Loop_size-k) of 5 steps to get to where they collide then it means that there are 3 more steps or k steps to the head of the circle. Because K = mod(k, loop_size), this works for any size of loop. And since it took slowRunner k step to get inside of the loop, the collision spot and head of the linked list is K steps away from the beginning of the loop. Then you can move the slow pointer back to the beginning and move step by step to find the head of the loop. Wow explaining it to someone else really helped me get this. I hope it helped you too. Let me know if something confused you.

check for circular linked list condition. c++ code: if(slow==fast) { slow=head; if(slow == fast) { while(fast->next != slow) fast = fast->next; } else { while(slow->next!=fast->next) { slow=slow->next; fast=fast->next; } } fast->next=NULL; }

@@manikanth.8507 Thanks man, Trying to find a solution since two hours . Your comment came as miracle !!!

This is linked list, so it will definitely be different from circular linked lists.

wow.

Thanks :)

Please share name of music