在循環鏈表中查找循環起始節點是如何工作的？

Question

我知道龜兔賽跑的結論是循環的存在，但是如何將烏龜移動到鏈表的開頭，同時將兔子保持在會合點，然后一次移動一步，讓他們在起點相遇周期？

Answer 1

讓我試着用我自己的話來闡明http://en.wikipedia.org/wiki/Cycle_detection#Tortoise_and_hare上提供的循環檢測算法。

這個怎么運作

讓我們有一只烏龜和一只兔子（指針的名稱）用一個循環指向列表的開頭，如上圖所示。

讓我們假設，如果我們一次移動烏龜 1 步，一次移動 2 步，它們最終會在某個點相遇。 讓我們首先證明這個假設是正確的。

該圖說明了一個帶有循環的列表。 循環的長度為n ，我們最初離循環有m步。 還假設交匯點距離循環開始點k步，當烏龜走完i步后，烏龜和野兔相遇。 （到那時，Hare 將總共采取2i步。）。

必須滿足以下 2 個條件：

1) i = m + p * n + k

2) 2i = m + q * n + k

第一個說烏龜移動i步，在這些i步中它首先進入循環。 然后它經過循環p次以獲取某個正數p 。 最后它又遍歷了k個節點，直到遇到野兔。

野兔也是如此。 它移動2i步，在這2i步中它首先進入循環。 然后它通過循環q次獲得某個正數q 。 最后它又遍歷了k個節點，直到遇到烏龜。

由於兔子以兩倍於烏龜的速度行進，因此當它們到達交匯點時，兩者的時間都是恆定的。

所以通過使用簡單的速度、時間和距離關系，

2 ( m + p * n + k ) = m + q * n + k

=> 2m + 2pn + 2k = m + nq + k 

=>  m + k = ( q - 2p ) n

在 m、n、k、p、q 中，前兩個是給定列表的屬性。 如果我們能證明至少有一組 k、q、p 值使這個等式成立，我們就表明假設是正確的。

一組這樣的解決方案如下：

p = 0

q = m

k = m n - m

我們可以驗證這些值的工作方式如下：

m + k = ( q - 2p ) n  

=> m + mn - m = ( m - 2*0) n

=> mn = mn.

對於這個集合， i是

i = m + p n + k

=> m + 0 * n + mn - m = mn.

當然，您應該看到這不一定是最小的 i 可能。 也就是說，龜兔可能已經見過很多次了。 但是，由於我們證明它們至少在某個時刻相遇一次，因此我們可以說該假設是正確的。 因此，如果我們將其中一個移動 1 步，而另一個移動 2 步，它們將不得不相遇。

現在我們可以進入算法的第二部分，即如何找到循環的開始。

周期開始

一旦烏龜和兔子相遇，讓我們將烏龜放回列表的開頭，並將兔子放在它們相遇的地方（距離循環開始的 k 步）。

假設是，如果我們讓他們以相同的速度移動（雙方各走一步），他們第一次再次相遇將是循環的開始。

讓我們來證明這個假設。

讓我們首先假設某個 oracle 告訴我們 m 是什么。

然后，如果我們讓它們移動 m + k 步，烏龜必須到達它們最初相遇的點（距循環開始 k 步 - 見圖）。

之前我們證明了m + k = (q - 2p) n 。

由於 m + k 步是循環長度 n 的倍數，因此野兔同時會經歷循環 (q-2p) 次並返回到同一點（距離循環開始的 k 步）。

現在，不是讓他們移動 m + k 步，如果我們讓他們只移動 m 步，烏龜會到達循環的開始。 Hare 距離完成 (q-2p) 旋轉還差 k 步。 由於它在循環開始前 k 步開始，因此野兔必須到達循環開始。

結果，這解釋了他們第一次必須在經過一些步數后的循環開始時相遇（這是第一次，因為烏龜在 m 步后才到達循環，它永遠看不到已經在的兔子循環）。

現在我們知道我們需要移動它們直到它們相遇的步數結果是從列表的開始到循環開始的距離，m。 當然，算法不需要知道m是什么。 它只會一步一步地移動烏龜和兔子，直到它們相遇。 交匯點必須是循環起點，步數必須是到循環起點的距離 (m)。 假設我們知道列表的長度，我們也可以計算從列表長度中減去 m 的循環長度。

Answer 2

參考這張圖片：

相遇前slowPointer 所走的距離= x + y

fastPointer 相遇前的距離= (x + y + z) + y = x + 2y + z

由於fastPointer行駛過程slowPointer兩倍的速度，時間是兩個常量，當到達會合點。

所以通過使用簡單的速度、時間和距離關系 2(x+y)= x+2y+z => x+2y+z = 2x+2y => x=z

因此，通過將slowPointer移動到鏈表的開頭，並使slowPointer 和fastPointer 一次移動一個節點，它們都具有相同的覆蓋距離。

它們將到達鏈表中循環開始的點。

Answer 3

這是Floyd 的循環檢測算法。 您是在詢問算法的第二階段——一旦您找到了一個屬於循環的節點，那么如何找到循環的開始？

在弗洛伊德算法的第一部分中，兔子每走一步就移動兩步。 如果烏龜和兔子相遇，則存在一個循環，並且相遇點是循環的一部分，但不一定是循環中的第一個節點。

當烏龜和兔子相遇時，我們已經找到了最小的 i（烏龜走的步數），使得 X _i = X _2i 。 讓 mu 表示從 X ₀到循環開始的步數，讓 lambda 表示循環的長度。 然后 i = mu + a lambda，和 2i = mu + b lambda，其中 a 和 b 是整數，表示烏龜和兔子在循環中走了多少次。 從第二個方程中減去第一個方程得到 i = (ba)*lambda，所以 i 是 lambda 的整數倍。 因此，X _{i + mu} = X _mu 。 X _i代表龜兔的交匯點。 如果你將烏龜移回起始節點 X ₀ ，讓烏龜和兔子以相同的速度繼續前進，經過 mu 額外的步驟，烏龜將達到 X _mu ，兔子將達到 X _{i + mu} = X _mu ，所以第二個交匯點表示循環的開始。

Answer 4

_{Old Monk 的簡單且未被投票的答案解釋了當快速跑步者僅完成單個完整循環時找到循環的原因。 在這個答案中，我解釋了快跑者在慢跑者進入循環之前多次運行循環的情況。}

---

使用相同的圖像：

假設快跑者在慢速和快速相遇之前已經運行了m次循環。 這意味着：

• 慢跑距離： x + y
• 快速奔跑的距離： x + m(y + z) + y即他們相遇的額外y

由於快跑的速度是慢跑的兩倍，而且他們跑的時間相同，這意味着如果我們慢跑的距離加倍，我們就會得到快跑的距離。 因此，

• 2(x + y) = x + m(y + z) + y

求解 x 給出，

x = (m - 1)(y + z) + z

在實際場景中，這意味着x = (m - 1)完整循環運行 + 額外距離z 。

因此，如果我們將一個指針放在列表的開頭，而將另一個指針放在會合點，那么以相同的速度移動它們將導致 in 循環指針完成m - 1次循環，然后遇到另一個指針在循環開始處。

Answer 5

這非常非常簡單。 您可以考慮相對速度。 如果兔子移動兩個節點，烏龜移動一個節點，相對於烏龜，兔子移動一個節點（假設烏龜靜止）。 所以，如果我們在循環鏈表中移動一個節點，我們肯定會在那個點再次相遇。

找到循環鏈表內部的連接點后，現在問題就歸結為尋找兩個鏈表的交點問題。

Answer 6

在第一次碰撞時，烏龜移動了m+k步，如上圖所示。 兔子的移動速度是烏龜的兩倍，這意味着兔子移動了2(m+k)步。 從這些簡單的事實我們可以得出以下圖表。

此時，我們將烏龜移回起點，並聲明兔子和烏龜都必須一次移動一步。 根據定義，在m步之后，烏龜將處於循環的開始。 野兔會在哪里？

野兔也將處於周期的開始。 這是從第二張圖明確：當烏龜被移回開始，兔子是k步到它的最后一個周期。 在m步之后，兔子將完成另一個循環並與烏龜相撞。

Answer 7

方法：

有兩個指針：

• 一次移動一個節點的慢指針。
• 一次移動兩個節點的快速指針。

如果兩個指針相遇，則證明存在循環。 一旦它們相遇，其中一個節點將指向頭部，然后同時進行一個節點。 他們將在循環開始時相遇。

理由：當兩個人沿着圓形軌道走時，其中一個人的速度是另一個人的兩倍，他們在哪里相遇？ 正是他們開始的地方。

現在，假設快跑者在n步圈中領先k步。 他們會在哪里見面？ 正好在nk步。 當慢跑者完成(nk)步時， (nk)者將完成k+2(nk)步。 （即， k+2n-2k步，即2n-k步）。 即(nk)步（路徑是圓形的，我們不關心他們相遇的回合數；我們只關心他們相遇的位置）。

現在，快跑者最初是如何領先k步的？ 因為慢跑者花了很多步才到達循環的起點。 所以循環的開始是從頭節點開始的 k 步。

注意：其中兩個指針滿足是節點k步驟從循環的開始離開（在循環內）和所述頭部節點也是k步驟從循環開始了。 因此，當我們讓指針從 bot 這些節點以 1 步的相同速度前進時，它們將在循環開始時相遇。

我相信這很簡單。 如果任何部分有歧義，請告訴我。

Answer 8

好的，讓我們假設兔子和烏龜在距離循環開始 k 步的點相遇，循環開始前的步數為 mu，循環的長度為 L。

所以現在在集合點 ->

烏龜覆蓋的距離 = mu + a*L + k - 公式 1

（到達循環開始所采取的步驟 + 覆蓋循環的“a”次迭代所采取的步驟 + 從循環開始的 k 步）（其中 a 是某個正常數）

野兔走過的距離 = mu + b*L + k - 公式 2

（到達循環開始所采取的步驟 + 覆蓋循環的“b”次迭代所采取的步驟 + 從循環開始的 k 步）（其中 b 是某個正常數且 b>=a）

所以兔子所覆蓋的額外距離是 = 方程 2 - 方程 1 = (ba)*L

請注意，這個距離也等於烏龜到起點的距離，因為兔子的移動速度是烏龜的 2 倍。 如果我們不包括循環的多次遍歷，這可以等同於“mu+k”，這也是會合點與起點的距離。

因此，mu + k = (ba)*L

因此，從這一點開始的 mu 步將導致回到循環的開始（因為從循環開始的 k 步已經被用於到達會合點）。 這可能發生在同一周期或任何后續周期中。 因此，現在如果我們將烏龜移動到鏈表的開頭，需要 mu 步才能到達循環的起點，而兔子也需要 mu 步才能到達循環的開頭，因此它們將在循環的起點。

PS 老實說，我腦子里和原來的海報有同樣的問題，我讀了第一個答案，他們確實清除了一些東西，但我無法清楚地得到最終結果，所以我嘗試以自己的方式去做，發現它更容易理解。

Answer 9

將問題簡化為循環問題，然后回到最初的問題

我覺得下面的解釋更直觀。

1. 取從頭部 ( O ) 開始的兩個指針 ( 1 = 烏龜和2 = 野兔)， 1的步長為1 ， 2的步長為2 。 想想1到達該循環的起始節點 ( A ) 的那一刻。

   我們想回答以下問題“當 1 在 A 中時，2 在哪里？” .

   所以， OA = a是一個自然數（ a >= 0 ）。 但它可以寫成以下方式： a = k*n + b ，其中a, k, n, b are natural numbers ：

   • n = 周期長度
   • k >= 0 = 常數
   • 0 <= b <= n-1

   這意味着b = a % n 。

   例如：如果a = 20 and n = 8 => k = 2 and b = 4因為20 = 2*8 + 4 。

   1所覆蓋的距離是d = OA = a = k*n + b 。 但同時， 2涵蓋D = 2*d = d + d = OA + d = OA + k*n + b 。 這意味着當2在 A 中時，它必須覆蓋k*n + b 。 正如你所看到的， k是圈數，但是那些圈后，2會是B遠離A.所以，我們發現其中2是當1是A.我們叫點B ，其中AB = b 。

   

2. 現在，我們將問題簡化為一個圓圈。 問題是“集合點在哪里？” . 那個C在哪里？

   

   在每一步中， 2 都減少了從1到1的距離（比方說米），因為1越來越遠離2和1 ，但同時2更接近1乘2 。

   因此，交點將是當1和2之間的距離為零時。 這意味着2減少了n - b距離。 為了實現這一點， 1將進行n - b步，而2將進行2*(n - b)步。

   所以，交點將是n - b遠離A （順時針），因為這是1所覆蓋的距離，直到它遇到2 。 => C和A之間的距離是CA = b ，因為AC = AB + BC = n - b和CA = n - AC 。 不要認為AC = CA ，因為AC距離不是一個微不足道的數學距離，它是A和C之間的步數（其中A是起點， C是終點）。

3. 現在，讓我們回到初始模式。

   我們知道a = k*n + b和CA = b 。

   我們可以采用 2 個新的指針1'和1'' ，其中1'從頭部（ O ）開始， 1''從交點（ C ）開始。

   當1'從O到A 時， 1''從C到A並繼續完成k圈。 所以，交點是A 。

   

   

Answer 10

使用高中教授的相對速度概念的簡單解釋 - 物理 101 / 運動學講座。

1. 讓我們假設從鏈表的起點到圓的起點的距離是x跳。 我們將圓的起點稱為X點（大寫 - 見上圖）。 還假設圓的總大小為 N 跳。

2. 兔子的速度 = 2 * 烏龜的速度。 所以這分別是1 hops/sec和2 hops/sec

3. 當烏龜到達圓X的起點時，兔子必須在圖中的Y點進一步跳x步。 （因為兔子的距離是烏龜的兩倍）。

4. 因此，從 X 到 Y 的順時針剩余弧的長度將為Nx 。 這也恰好是兔子和烏龜之間能夠相遇的相對距離。 假設這個相對距離將在時間t_m即相遇時間。 相對速度是(2 hops/sec - 1 hops/sec)即1 hops/sec 。 因此使用，相對距離 = 相對速度 X 時間，我們得到， t = Nx秒。 所以到達烏龜和兔子的交匯點需要Nx 。

5. 現在在Nx秒的時間內以1 hops/sec速度，較早在X點的烏龜將經過 Nx 跳到達會合點M 。 因此，這意味着會合點M位於從X = 逆時針Nx跳處（這進一步暗示）=> 從點M到X順時針剩余x距離。

6. 但是x也是從鏈表的起點到X點的距離。

7. 現在，我們不關心x對應的跳數是多少。 如果我們將一只烏龜放在 LinkedList 的開頭，將一只烏龜放在會合點M並讓它們跳躍/行走，那么它們將在X點相遇，這就是我們需要的點（或節點）。

Answer 11

- 循環前有 k 步。 我們不知道 k 是什么，也不需要找出來。 我們可以只用 k 抽象地工作。

--經過k步

----- T 在循環開始

----- H 是 k 步進入循環（他總共走了 2k，因此 k 進入循環）

** 他們現在是loopsize - k 分開

（注意 k == K == mod(loopsize, k) -- 例如，如果一個節點是 2 步進入 5 節點循環，它也是 7、12 或 392 步，所以循環有多大 wrt k 不考慮到。

由於它們以每單位時間 1 步的速度相互追趕，因為一個移動的速度是另一個的兩倍，因此它們將在循環大小 - k 處相遇。

這意味着需要 k 個節點才能到達循環的起點，因此從頭到循環起點和碰撞到循環起點的距離是相同的。

所以現在在第一次碰撞后將 T 移回頭部。 如果您以 1 的速率移動，T 和 H 將在循環開始時相遇。 （兩者都在 k 步中）

這意味着算法是：

• 從頭部移動 T = t.next 和 H.next.next 直到它們碰撞（ T == H）（有一個循環）

//通過計算循環的長度來處理當 k=0 或 T 和 H 在循環的開頭相遇時的情況

-- 用計數器移動 T 或 H 來計算循環的長度

-- 將指針 T2 移動到列表的頭部

--move 循環步長的指針長度

--將另一個指針 H2 移動到頭部

--同時移動 T2 和 H2 直到它們在循環開始時相遇

就是這樣！

Answer 12

如圖所示，如果指針在P點相遇，距離Z+Y就是P點，X+Y也是P點，即Z=X。 這就是為什么保持從 P 移動一個指針並將另一個從 start(S) 移動到它們相遇的原因，這意味着將相等的距離（Z 或 X）移動到同一點 M（距離 P 的距離 Z 和距離 S 的 X 的距離）將是循環的開始。 簡單的！

Answer 13

形象信用

將指針跟隨的鏈接數稱為距離，並計算算法將慢指針移動一個鏈接並將快速指針移動兩個鏈接所需的迭代次數。 在長度為 C 的循環之前有 N 個節點，標記為循環偏移 k=0 到 C-1。

為了到達循環的開始，slow 需要 N 時間和距離。 這意味着快速在循環中需要 N 距離（N 到達那里，N 旋轉）。 所以在時間 N，slow 處於周期偏移 k=0，fast 處於周期偏移 k=N mod C。

如果 N mod C 為零，則慢速和快速現在匹配並且在時間 N 和循環位置 k=0 找到循環。

如果 N mod C 不為零，那么快現在必須趕上慢，在時間 N 是循環中落后 C-(N mod C) 距離。

由於快移動每慢 1 移動 2，每次迭代將距離減少 1，因此這需要的額外時間與時間 N 時快與慢之間的距離一樣多，即 C-(N mod C)。 由於慢是從偏移量 0 開始移動，這也是它們相遇的偏移量。

因此，如果 N mod C 為零，則階段 1 在循環開始時經過 N 次迭代后停止。 否則，階段 1 在 N+C-(N mod C) 次迭代后停止，偏移量 C-(N mod C) 進入循環。

// C++ pseudocode, end() is one after last element.

int t = 0;
T *fast = begin();
T *slow = begin();
if (fast == end()) return [N=0,C=0];
for (;;) {
    t += 1;
    fast = next(fast);
    if (fast == end()) return [N=(2*t-1),C=0];
    fast = next(fast);
    if (fast == end()) return [N=(2*t),C=0];
    slow = next(slow);
    if (*fast == *slow) break;
}

好的，所以階段 2：slow 需要多 N 步才能進入循環，此時快速（現在每個時間步移動 1）在 (C-(N mod C)+N) mod C = 0。所以他們相遇在第 2 階段之后的周期開始時。

int N = 0;
slow = begin();
for (;;) {
    if (*fast == *slow) break;
    fast = next(fast);
    slow = next(slow);
    N += 1;
}

為完整起見，第 3 階段通過在循環中再次移動來計算循環長度：

int C = 0;
for (;;) {
    fast = next(fast);
    C += 1;
    if (fast == slow) break;
}

Answer 14

對此已經有很多答案，但我曾經為此想出了一個圖表，這對我來說在視覺上更直觀。 也許它可以幫助其他人。

對我來說主要的啊哈時刻是：

• 將T （烏龜）拆分為T1 （預循環）和T2 （循環內）。

• 從H 中減去T ，它們在視覺上重疊。 剩下的 ( H - T = H' ) 等於T 。

• 剩下的數學很簡單。

Answer 15

通過上述所有分析，如果您是一個以身作則的人，我嘗試編寫一個簡短的分析和示例，以幫助解釋其他人試圖解釋的數學。 開始了！

分析：

如果我們有兩個指針，一個比另一個快，並將它們一起移動，它們最終將再次相遇以指示循環或空值指示沒有循環。

要找到循環的起點，讓...

1. m是從頭部到循環開始的距離；

2. d是循環中的節點數；

3. p1是較慢指針的速度；

4. p2是較快指針的速度，例如。 2 表示一次通過兩個節點。

   觀察以下迭代：

 m = 0, d = 10: p1 = 1: 0 1 2 3 4 5 6 7 8 9 10 // 0 would the start of the cycle p2 = 2: 0 2 4 6 8 10 12 14 16 18 20 m = 1, d = 10: p1 = 1: -1 0 1 2 3 4 5 6 7 8 9 p2 = 2: -1 1 3 5 7 9 11 13 15 17 19 m = 2, d = 10: p1 = 1: -2 -1 0 1 2 3 4 5 6 7 8 p2 = 2: -2 0 2 4 6 8 10 12 14 16 18

從上面的樣本數據中，我們不難發現，每當快慢指針相遇時，它們都離循環開始有m步之遙。 為了解決這個問題，將較快的指針放回頭部並將其速度設置為較慢指針的速度。 當他們再次相遇時，節點是循環的開始。

Answer 16

我不認為這是真的，當他們相遇時，那是起點。 但是是的，如果另一個指針（F）在之前的交匯點處，那么該指針將在循環的末尾而不是循環的開始，而指針（S）將從列表的開頭開始結束在循環的開始。 例如：

1->2->3->4->5->6->7->8->9->10->11->12->13->14->15->16->17->18->19->20->21->22->23->24->8

Meet at :16

Start at :8

public Node meetNodeInLoop(){

    Node fast=head;
    Node slow=head;

    fast=fast.next.next;
    slow=slow.next;

    while(fast!=slow){

        fast=fast.next;
        fast=fast.next;

        if(fast==slow) break; 

        slow=slow.next;
    }

    return fast;

}

public Node startOfLoop(Node meet){

    Node slow=head;
    Node fast=meet;

    while(slow!=fast){
        fast=fast.next;
        if(slow==fast.next) break;
        slow=slow.next;
    }

    return slow;
}

Answer 17

可以說，

N[0] is the node of start of the loop, 
m is the number of steps from beginning to N[0].

我們有 2 個指針 A 和 B，A 以 1x 速度運行，B 以 2x 速度運行，兩者都從頭開始。

當 A 到達 N[0] 時，B 應該已經在 N[m] 中。 （注：A用m步到達N[0]，B應該再m步）

然后，A 再跑 k 步與 B 碰撞，即 A 在 N[k]，B 在 N[m+2k]（注意：B 應該從 N[m] 開始運行 2k 步）

A 分別在 N[k] 和 N[m+2k] 處碰撞 B，這意味着 k=m+2k，因此 k = -m

因此，要從 N[k] 循環回到 N[0]，我們還需要 m 個步驟。

簡單地說，我們只需要在找到碰撞節點后多運行 m 步即可。 我們可以有一個從頭開始運行的指針和一個從碰撞節點運行的指針，它們將在 m 步后在 N[0] 處相遇。

因此，偽代碼如下：

1) A increase 1 step per loop
2) B increase 2 steps per loop
3) if A & B are the same node, cycle found, then go to 5
4) repeat from 1
5) A reset to head
6) A increase 1 step per loop
7) B increase 1 step per loop
8) if A & B are the same node, start of the cycle found
9) repeat from 6

Answer 18

使用圖表進行處理會有所幫助。 我試圖在沒有方程的情況下解釋這個問題。

1. 如果我們讓兔子和烏龜跑一圈，兔子跑兩次烏龜，那么一圈結束時，兔子烏龜跑到一半。 在兩圈結束時，兔子烏龜會跑一圈，他們都相遇了。 這適用於所有速度，例如如果兔子跑了 3 次，兔子 1 圈等於烏龜的 1/3，所以在 3 圈結束時，兔子烏龜會跑完 1 圈然后它們相遇。
2. 現在，如果我們在循環前 m 步啟動它們，那么這意味着更快的兔子在循環中提前開始。 因此，如果烏龜到達循環的起點，兔子會提前 m 步循環，當它們相遇時，它將在循環開始前 m 步。

Answer 19

我看到大多數答案對此給出了數學解釋“如何將烏龜移動到鏈表的開頭，同時將野兔保持在會面位置，然后一次移動一步，使它們在循環的起點相遇？ ”

以下方法在幕后也執行與弗洛伊德循環檢測相同的操作，但原理很簡單，但以 O(n) 內存為代價。

我想添加一個更簡單的方法/理由來找到循環的開始。 由於在任何地方都沒有提到這個方法，我在這里測試了這個： https : //leetcode.com/problems/linked-list-cycle-ii/並且它通過了所有的測試用例。

讓我們考慮一下，我們已經獲得了 LinkedList 的頭部引用。

     public ListNode detectCycle(ListNode head) {
     
            // Consider a fast pointer which hops two nodes at once.
            // Consider a slow pointer which hops one node at once.
            // If the linked list contains a cycle,
            // these two pointers would meet at some point when they are looping around the list.
            // Caution: This point of intersection need not be the beginning of the cycle.
            ListNode fast = null;
            ListNode slow = null;
            if (head != null) {
                if (head.next != null) {
                    fast = head.next.next;
                    slow = head;
                } else {
                    return null;
                }
            }
            while (fast != null && fast.next != null) {
                // Why do we need collection here? Explained below
                Set<ListNode> collection = new HashSet<>();
                if (fast == slow) {
                  // Once the cycle is detected, 
                     we are sure that there is beginning to the cycle.
                  // In order to find this beginning, 
                  // 1. move slow pointer to head and keep fast pointer at 
                        the meeting point.
                  // 2. now while moving slow and fast pointers through a 
                        single hop, store the slow reference in a collection.
                  // 3. Every time you hop the fast pointer, check the fast 
                        pointer reference exits in that collection.
                  // Rationale: After we moved slow pointer to the head, 
                     we know that slow pointer is coming behind the fast
                     pointer, since collection is storing all nodes from the 
                     start using slow pointer, there is only one case we get 
                     that fast pointer exists in the collection when slow 
                     pointer started storing the nodes which are part of the 
                     cycle. Because slow pointer can never go ahead of fast 
                     pointer since fast pointer already has an head-start, at 
                     the same time, the first occurence will always be of the 
                     starting point of the cycle because slow pointer can't 
                     go ahead of fast pointer to store other nodes in the 
                     cycle. So, the moment we first find fast pointer in that 
                     collection means, that is the starting point of the 
                     cycle.
                    slow = head;
                    collection.add(slow);
                    while (!collection.contains(fast)) {
                        slow = slow.next;
                        collection.add(slow);
                        fast = fast.next;
                    }
                    return fast;
                }
                fast = fast.next.next;
                slow = slow.next;
            }
            return null;
        }

Answer 20

在花了兩個小時試圖閱讀所有答案后，我在 leetcode 上找到了這條評論。 可以肯定地說，它拯救了我的夜晚。

https://leetcode.com/problems/linked-list-cycle-ii/discuss/44774/Java-O(1)-space-solution-with-detailed-explanation./44281

Answer 21

如果您考慮會合點背后的數學原理，實際上很容易證明他們會在起點會合。
首先讓m表示鏈表中循環的起點， n表示循環的長度。 然后為了兔子和烏龜相遇，我們有：

( 2*t - m )%n = (t - m) %n, where t = time (at t = 0 , both are at the start)

更數學地說明這一點：

(2*t - m - (t - m) ) = 0 modulo n , which implies , t = 0 modulo n 

所以他們會在時間t相遇，這應該是周期長度的倍數。 這意味着它們在一個位置相遇，即(tm) modulo n = (0-m) modulo n = (-m) modulo n 。

所以現在回到這個問題，如果你從鏈表的開頭移動一個指針，另一個從交點移動，經過 m 步后，我們將使野兔（在循環內移動）到達一個點，即((-m) + m) modulo n = 0 modulo n就是循環的起點。將從鏈表的開頭遍歷m步。

作為旁注，我們也可以這樣計算它們相交的時間：條件t = 0 modulo n告訴我們它們將在周期長度倍數的時間相遇，並且t應該大於m 。因為他們會在循環中相遇。 所以所用的時間將等於n的第一個大於m 的倍數。

Answer 22

假設您的指針在 y 和 z 點相交。

n 和 m 分別是較快和較慢的指針在相遇之前的循環次數。

有關證明的其余部分，請參閱圖像。 在鏈表中找到循環的起點

Answer 23

我知道這個問題已經有一個公認的答案，但我仍然會嘗試以流暢的方式回答。 認為 ：

The length of the Path is 'X+B' where 'B' is the length of the looped path and X of the non looped path. 
    Speed of tortoise : v
    Speed of hare     : 2*v 
    Point where both meet is at a distance 'x + b - k' from the starting point.

現在，讓兔子和烏龜在時間 't' 后相遇。

觀察：

如果，烏龜行走的距離 = v*t = x + (bk)（比如說）

然后，野兔行進的距離 = 2*v*t = x + (b - k) + b（因為野兔已經穿過循環部分一次）

現在，會議時間相同。

=> x + 2*b - k = 2* (x + b - k)

=> x = k

這當然意味着未循環的路徑的長度與循環起點與兩者相遇點的距離相同。