日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
五個解決辦法教你C++中檢測鏈表中的循環(huán)

給定一個鏈表，檢查鏈表是否有循環(huán)。下圖顯示了帶有循環(huán)的鏈表。

專注于為中小企業(yè)提供網(wǎng)站建設(shè)、網(wǎng)站制作服務(wù),電腦端+手機(jī)端+微信端的三站合一,更高效的管理,為中小企業(yè)寧德免費(fèi)做網(wǎng)站提供優(yōu)質(zhì)的服務(wù)。我們立足成都，凝聚了一批互聯(lián)網(wǎng)行業(yè)人才，有力地推動了千余家企業(yè)的穩(wěn)健成長，幫助中小企業(yè)通過網(wǎng)站建設(shè)實現(xiàn)規(guī)模擴(kuò)充和轉(zhuǎn)變。

以下是執(zhí)行此操作的不同方法 

解決方案1：散列方法：

遍歷該列表，并將節(jié)點(diǎn)地址始終放在哈希表中。在任何時候，如果達(dá)到NULL，則返回false，如果當(dāng)前節(jié)點(diǎn)的下一個指向Hash中先前存儲的任何節(jié)點(diǎn)，則返回true。

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3. struct Node { 
    4. 
  
  
  
  4.     int data; 
    5. 
  
  
  
  5.     struct Node* next; 
    6. 
  
  
  
  6. }; 
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8. void push(struct Node** head_ref, int new_data) 
    9. 
  
  
  
  9. { 
    10. 
  
  
  
  10.     struct Node* new_node = new Node; 
    11. 
  
  
  
  11.     new_node->data = new_data; 
    12. 
  
  
  
  12.     new_node->next = (*head_ref); 
    13. 
  
  
  
  13.     (*head_ref) = new_node; 
    14. 
  
  
  
  14. } 
    15. 
  
  
  
  15. bool detectLoop(struct Node* h) 
    16. 
  
  
  
  16. { 
    17. 
  
  
  
  17.     unordered_set s; 
    18. 
  
  
  
  18.     while (h != NULL) { 
    19. 
  
  
  
  19.         if (s.find(h) != s.end()) 
    20. 
  
  
  
  20.             return true; 
    21. 
  
  
  
  21.         s.insert(h); 
    22. 
  
  
  
  22.   
    23. 
  
  
  
  23.         h = h->next; 
    24. 
  
  
  
  24.     } 
    25. 
  
  
  
  25.   
    26. 
  
  
  
  26.     return false; 
    27. 
  
  
  
  27. } 
    28. 
  
  
  
  28. int main() 
    29. 
  
  
  
  29. { 
    30. 
  
  
  
  30.     struct Node* head = NULL; 
    31. 
  
  
  
  31.   
    32. 
  
  
  
  32.     push(&head, 20); 
    33. 
  
  
  
  33.     push(&head, 4); 
    34. 
  
  
  
  34.     push(&head, 15); 
    35. 
  
  
  
  35.     push(&head, 10); 
    36. 
  
  
  
  36.     head->next->next->next->next = head; 
    37. 
  
  
  
  37.   
    38. 
  
  
  
  38.     if (detectLoop(head)) 
    39. 
  
  
  
  39.         cout << "Loop found"; 
    40. 
  
  
  
  40.     else 
    41. 
  
  
  
  41.         cout << "No Loop"; 
    42. 
  
  
  
  42.   
    43. 
  
  
  
  43.     return 0; 
    44. 
  
  
  
  44. } 
    45.

復(fù)雜度分析：

時間復(fù)雜度： O（n）。
只需循環(huán)一次即可。

輔助空間： O（n）。
n是將值存儲在哈希圖中所需的空間。

解決方案2：通過修改鏈表數(shù)據(jù)結(jié)構(gòu)，無需哈希圖即可解決此問題。
方法：此解決方案需要修改基本鏈表數(shù)據(jù)結(jié)構(gòu)。

  • 每個節(jié)點(diǎn)都有一個訪問標(biāo)志。
  • 遍歷鏈接列表并繼續(xù)標(biāo)記訪問的節(jié)點(diǎn)。
  • 如果您再次看到一個訪問過的節(jié)點(diǎn)，那么就會有一個循環(huán)。該解決方案適用于O（n），但每個節(jié)點(diǎn)都需要其他信息。
  • 此解決方案的一種變體不需要修改基本數(shù)據(jù)結(jié)構(gòu)，可以使用哈希來實現(xiàn)，只需將訪問的節(jié)點(diǎn)的地址存儲在哈希中，如果您看到哈希中已經(jīng)存在的地址，則存在一個循環(huán)。

C++：

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3. struct Node { 
    4. 
  
  
  
  4.     int data; 
    5. 
  
  
  
  5.     struct Node* next; 
    6. 
  
  
  
  6.     int flag; 
    7. 
  
  
  
  7. }; 
    8. 
  
  
  
  8.   
    9. 
  
  
  
  9. void push(struct Node** head_ref, int new_data) 
    10. 
  
  
  
  10. { 
    11. 
  
  
  
  11.     struct Node* new_node = new Node; 
    12. 
  
  
  
  12.     new_node->data = new_data; 
    13. 
  
  
  
  13.   
    14. 
  
  
  
  14.     new_node->flag = 0; 
    15. 
  
  
  
  15.     new_node->next = (*head_ref); 
    16. 
  
  
  
  16.     (*head_ref) = new_node; 
    17. 
  
  
  
  17. } 
    18. 
  
  
  
  18. bool detectLoop(struct Node* h) 
    19. 
  
  
  
  19. { 
    20. 
  
  
  
  20.     while (h != NULL) { 
    21. 
  
  
  
  21.         if (h->flag == 1) 
    22. 
  
  
  
  22.             return true; 
    23. 
  
  
  
  23.         h->flag = 1; 
    24. 
  
  
  
  24.   
    25. 
  
  
  
  25.         h = h->next; 
    26. 
  
  
  
  26.     } 
    27. 
  
  
  
  27.   
    28. 
  
  
  
  28.     return false; 
    29. 
  
  
  
  29. } 
    30. 
  
  
  
  30. int main() 
    31. 
  
  
  
  31. { 
    32. 
  
  
  
  32.     struct Node* head = NULL; 
    33. 
  
  
  
  33.   
    34. 
  
  
  
  34.     push(&head, 20); 
    35. 
  
  
  
  35.     push(&head, 4); 
    36. 
  
  
  
  36.     push(&head, 15); 
    37. 
  
  
  
  37.     push(&head, 10); 
    38. 
  
  
  
  38.     head->next->next->next->next = head; 
    39. 
  
  
  
  39.   
    40. 
  
  
  
  40.     if (detectLoop(head)) 
    41. 
  
  
  
  41.         cout << "Loop found"; 
    42. 
  
  
  
  42.     else 
    43. 
  
  
  
  43.         cout << "No Loop"; 
    44. 
  
  
  
  44.   
    45. 
  
  
  
  45.     return 0; 
    46. 
  
  
  
  46. } 
    47.

復(fù)雜度分析：

時間復(fù)雜度： O（n）。
只需循環(huán)一次即可。

輔助空間： O（1）。
不需要額外的空間。

解決方案3：Floyd的循環(huán)查找算法
方法：這是最快的方法，下面進(jìn)行了介紹：

  • 使用兩個指針遍歷鏈表。
  • 將一個指針（slow_p）移動一個，將另一個指針（fast_p）移動兩個。
  • 如果這些指針在同一節(jié)點(diǎn)相遇，則存在循環(huán)。如果指針不符合要求，則鏈接列表沒有循環(huán)。

Floyd的循環(huán)查找算法的實現(xiàn)：

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3. class Node { 
    4. 
  
  
  
  4. public: 
    5. 
  
  
  
  5.     int data; 
    6. 
  
  
  
  6.     Node* next; 
    7. 
  
  
  
  7. }; 
    8. 
  
  
  
  8.   
    9. 
  
  
  
  9. void push(Node** head_ref, int new_data) 
    10. 
  
  
  
  10. { 
    11. 
  
  
  
  11.     Node* new_node = new Node(); 
    12. 
  
  
  
  12.     new_node->data = new_data; 
    13. 
  
  
  
  13.     new_node->next = (*head_ref); 
    14. 
  
  
  
  14.     (*head_ref) = new_node; 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16.   
    17. 
  
  
  
  17. int detectLoop(Node* list) 
    18. 
  
  
  
  18. { 
    19. 
  
  
  
  19.     Node *slow_p = list, *fast_p = list; 
    20. 
  
  
  
  20.   
    21. 
  
  
  
  21.     while (slow_p && fast_p && fast_p->next) { 
    22. 
  
  
  
  22.         slow_p = slow_p->next; 
    23. 
  
  
  
  23.         fast_p = fast_p->next->next; 
    24. 
  
  
  
  24.         if (slow_p == fast_p) { 
    25. 
  
  
  
  25.             return 1; 
    26. 
  
  
  
  26.         } 
    27. 
  
  
  
  27.     } 
    28. 
  
  
  
  28.     return 0; 
    29. 
  
  
  
  29. } 
    30. 
  
  
  
  30. int main() 
    31. 
  
  
  
  31. { 
    32. 
  
  
  
  32.     Node* head = NULL; 
    33. 
  
  
  
  33.   
    34. 
  
  
  
  34.     push(&head, 20); 
    35. 
  
  
  
  35.     push(&head, 4); 
    36. 
  
  
  
  36.     push(&head, 15); 
    37. 
  
  
  
  37.     push(&head, 10); 
    38. 
  
  
  
  38.     head->next->next->next->next = head; 
    39. 
  
  
  
  39.     if (detectLoop(head)) 
    40. 
  
  
  
  40.         cout << "Loop found"; 
    41. 
  
  
  
  41.     else 
    42. 
  
  
  
  42.         cout << "No Loop"; 
    43. 
  
  
  
  43.     return 0; 
    44. 
  
  
  
  44. } 
    45.

解決方案4：在不修改鏈接列表數(shù)據(jù)結(jié)構(gòu)的情況下標(biāo)記訪問的節(jié)點(diǎn)
在此方法中，將創(chuàng)建一個臨時節(jié)點(diǎn)。使遍歷的每個節(jié)點(diǎn)的下一個指針指向該臨時節(jié)點(diǎn)。這樣，我們將節(jié)點(diǎn)的下一個指針用作標(biāo)志來指示該節(jié)點(diǎn)是否已遍歷。檢查每個節(jié)點(diǎn)以查看下一個節(jié)點(diǎn)是否指向臨時節(jié)點(diǎn)。在循環(huán)的第一個節(jié)點(diǎn)的情況下，第二次遍歷該條件將成立，因此我們發(fā)現(xiàn)該循環(huán)存在。如果遇到一個指向null的節(jié)點(diǎn)，則循環(huán)不存在。
下面是上述方法的實現(xiàn)：

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4. struct Node { 
    5. 
  
  
  
  5.     int key; 
    6. 
  
  
  
  6.     struct Node* next; 
    7. 
  
  
  
  7. }; 
    8. 
  
  
  
  8.   
    9. 
  
  
  
  9. Node* newNode(int key) 
    10. 
  
  
  
  10. { 
    11. 
  
  
  
  11.     Node* temp = new Node; 
    12. 
  
  
  
  12.     temp->key = key; 
    13. 
  
  
  
  13.     temp->next = NULL; 
    14. 
  
  
  
  14.     return temp; 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16. void printList(Node* head) 
    17. 
  
  
  
  17. { 
    18. 
  
  
  
  18.     while (head != NULL) { 
    19. 
  
  
  
  19.         cout << head->key << " "; 
    20. 
  
  
  
  20.         head = head->next; 
    21. 
  
  
  
  21.     } 
    22. 
  
  
  
  22.     cout << endl; 
    23. 
  
  
  
  23. } 
    24. 
  
  
  
  24. bool detectLoop(Node* head) 
    25. 
  
  
  
  25. { 
    26. 
  
  
  
  26.     Node* temp = new Node; 
    27. 
  
  
  
  27.     while (head != NULL) { 
    28. 
  
  
  
  28.         if (head->next == NULL) { 
    29. 
  
  
  
  29.             return false; 
    30. 
  
  
  
  30.         } 
    31. 
  
  
  
  31.         if (head->next == temp) { 
    32. 
  
  
  
  32.             return true; 
    33. 
  
  
  
  33.         } 
    34. 
  
  
  
  34.         Node* nex = head->next; 
    35. 
  
  
  
  35.         head->next = temp; 
    36. 
  
  
  
  36.         head = nex; 
    37. 
  
  
  
  37.     } 
    38. 
  
  
  
  38.   
    39. 
  
  
  
  39.     return false; 
    40. 
  
  
  
  40. } 
    41. 
  
  
  
  41. int main() 
    42. 
  
  
  
  42. { 
    43. 
  
  
  
  43.     Node* head = newNode(1); 
    44. 
  
  
  
  44.     head->next = newNode(2); 
    45. 
  
  
  
  45.     head->next->next = newNode(3); 
    46. 
  
  
  
  46.     head->next->next->next = newNode(4); 
    47. 
  
  
  
  47.     head->next->next->next->next = newNode(5); 
    48. 
  
  
  
  48.     head->next->next->next->next->next = head->next->next; 
    49. 
  
  
  
  49.   
    50. 
  
  
  
  50.     bool found = detectLoop(head); 
    51. 
  
  
  
  51.     if (found) 
    52. 
  
  
  
  52.         cout << "Loop Found"; 
    53. 
  
  
  
  53.     else 
    54. 
  
  
  
  54.         cout << "No Loop"; 
    55. 
  
  
  
  55.   
    56. 
  
  
  
  56.     return 0; 
    57. 
  
  
  
  57. } 
    58.

復(fù)雜度分析：

時間復(fù)雜度： O（n）。
只需循環(huán)一次即可。

輔助空間： O（1）。
不需要空間。

解決方案5：存放長度

在此方法中，將創(chuàng)建兩個指針，第一個（始終指向頭）和最后一個指針。每次最后一個指針移動時，我們都會計算第一個和最后一個之間的節(jié)點(diǎn)數(shù)，并檢查當(dāng)前節(jié)點(diǎn)數(shù)是否大于先前的節(jié)點(diǎn)數(shù)，如果是，我們通過移動最后一個指針進(jìn)行操作，否則就意味著我們已經(jīng)到達(dá)循環(huán)的終點(diǎn)，因此我們相應(yīng)地返回輸出。

 
 
 
    
  
  
  
  1. #include  
    2. 
  
  
  
  2. using namespace std; 
    3. 
  
  
  
  3.   
    4. 
  
  
  
  4. struct Node { 
    5. 
  
  
  
  5.     int key; 
    6. 
  
  
  
  6.     struct Node* next; 
    7. 
  
  
  
  7. }; 
    8. 
  
  
  
  8.   
    9. 
  
  
  
  9. Node* newNode(int key) 
    10. 
  
  
  
  10. { 
    11. 
  
  
  
  11.     Node* temp = new Node; 
    12. 
  
  
  
  12.     temp->key = key; 
    13. 
  
  
  
  13.     temp->next = NULL; 
    14. 
  
  
  
  14.     return temp; 
    15. 
  
  
  
  15. } 
    16. 
  
  
  
  16. void printList(Node* head) 
    17. 
  
  
  
  17. { 
    18. 
  
  
  
  18.     while (head != NULL) { 
    19. 
  
  
  
  19.         cout << head->key << " "; 
    20. 
  
  
  
  20.         head = head->next; 
    21. 
  
  
  
  21.     } 
    22. 
  
  
  
  22.     cout << endl; 
    23. 
  
  
  
  23. } 
    24. 
  
  
  
  24. int distance(Node* first, Node* last) 
    25. 
  
  
  
  25. { 
    26. 
  
  
  
  26.     int counter = 0; 
    27. 
  
  
  
  27.   
    28. 
  
  
  
  28.     Node* curr; 
    29. 
  
  
  
  29.     curr = first; 
    30. 
  
  
  
  30.   
    31. 
  
  
  
  31.     while (curr != last) { 
    32. 
  
  
  
  32.         counter += 1; 
    33. 
  
  
  
  33.         curr = curr->next; 
    34. 
  
  
  
  34.     } 
    35. 
  
  
  
  35.   
    36. 
  
  
  
  36.     return counter + 1; 
    37. 
  
  
  
  37. } 
    38. 
  
  
  
  38. bool detectLoop(Node* head) 
    39. 
  
  
  
  39.     Node* temp = new Node; 
    40. 
  
  
  
  40.   
    41. 
  
  
  
  41.     Node *first, *last; 
    42. 
  
  
  
  42.     first = head; 
    43. 
  
  
  
  43.     last = head; 
    44. 
  
  
  
  44.     int current_length = 0; 
    45. 
  
  
  
  45.     int prev_length = -1; 
    46. 
  
  
  
  46.   
    47. 
  
  
  
  47.     while (current_length > prev_length && last != NULL) { 
    48. 
  
  
  
  48.           prev_length = current_length; 
    49. 
  
  
  
  49.         current_length = distance(first, last); 
    50. 
  
  
  
  50.         last = last->next; 
    51. 
  
  
  
  51.     } 
    52. 
  
  
  
  52.       
    53. 
  
  
  
  53.     if (last == NULL) { 
    54. 
  
  
  
  54.         return false; 
    55. 
  
  
  
  55.     } 
    56. 
  
  
  
  56.     else {  
    57. 
  
  
  
  57.         return true; 
    58. 
  
  
  
  58.     } 
    59. 
  
  
  
  59. } 
    60. 
  
  
  
  60. int main() 
    61. 
  
  
  
  61. { 
    62. 
  
  
  
  62.     Node* head = newNode(1); 
    63. 
  
  
  
  63.     head->next = newNode(2); 
    64. 
  
  
  
  64.     head->next->next = newNode(3); 
    65. 
  
  
  
  65.     head->next->next->next = newNode(4); 
    66. 
  
  
  
  66.     head->next->next->next->next = newNode(5); 
    67. 
  
  
  
  67.     head->next->next->next->next->next = head->next->next; 
    68. 
  
  
  
  68.   
    69. 
  
  
  
  69.     bool found = detectLoop(head); 
    70. 
  
  
  
  70.     if (found) 
    71. 
  
  
  
  71.         cout << "Loop Found"; 
    72. 
  
  
  
  72.     else 
    73. 
  
  
  
  73.         cout << "No Loop Found"; 
    74. 
  
  
  
  74.   
    75. 
  
  
  
  75.     return 0; 
    76. 
  
  
  
  76. } 
    77.

}


網(wǎng)站名稱：五個解決辦法教你C++中檢測鏈表中的循環(huán)
分享地址：http://m.5511xx.com/article/dpdoepe.html