深圳幻海软件技术有限公司 欢迎您！
更多

C++ 链表

2023-05-30

null next cur
目录链表结构一，单链表1.实现基本的增删查改 2.对链表进行一些操作（1）删除等于给定值的所有节点。（2）翻转链表（3）返回中间节点的地址（4）倒数第k个节点  （5）合并有序链表 （6）分割链表（7）链表回文（8）链表相交  （9）环形链

目录

链表结构

一，单链表

1.实现基本的增删查改

 2.对链表进行一些操作

（1）删除等于给定值的所有节点。

（2）翻转链表

（3） 返回中间节点的地址

（4）倒数第k个节点 

 （5）合并有序链表

 （6）分割链表

（7）链表回文

（8）链表相交 

 （9）环形链表

二，双向链表

1.增删查改

虽然C++中有list容器，但是在某些oj题中会出现有关链表的题，所以写一篇C++链表。

省去太过官方的定义，只做最简单易懂的介绍。

链表结构

一个数据所在的内存块被分为两个部分，第一个部分放数据，而第二个部分则放下一个数据的地址，以此来连接各个数据，最后一个内存块放的地址为NULL。这样的一个内存块叫做节点。

在代码中，链表的一个节点是这样的：

  1. struct ListNode
  2. {
  3. int data;
  4. ListNode* next;//结构体指针
  5. };

链表有一定的缺陷：每存放一个数据都需要伴随下一个数据的地址并且不支持随机访问。

一，单链表

先来看最简单的单链表。

1.实现基本的增删查改

  1. #include<algorithm>
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. struct ListNode
  6. {
  7. int data;
  8. ListNode* next;//结构体指针
  9. };
  10. void Listprintf(ListNode* phead)
  11. {
  12. ListNode* cur=phead;
  13. while (cur != NULL)
  14. {
  15. cout << cur->data << "->";
  16. cur = cur->next;
  17. }
  18. }
  19. void Listpushback(ListNode** pphead, int x)
  20. {
  21. ListNode* newnode = new ListNode{ x,NULL };
  22. if (*pphead == NULL)
  23. {
  24. *pphead = newnode;
  25. }
  26. else
  27. {
  28. ListNode* tail=  *pphead;
  29. while(tail->next != NULL)
  30. {
  31. tail = tail->next;
  32. }
  33. tail->next = newnode;
  34. }
  35. }
  36. void test_1()
  37. {
  38. ListNode* phead = NULL;
  39. Listpushback(&phead, 1);
  40. Listpushback(&phead, 2);
  41. Listpushback(&phead, 3); 
  42. Listprintf(phead);
  43. }
  44. int main()
  45. {
  46. test_1();
  47. return 0;
  48. }

运行结果：

在这段代码中有一些需要注意的地方，比如：

在Listpushback这个函数中，参数是二级指针，如果写成一级指针：

  1. void Listpushback(ListNode* pphead, int x)
  2. {
  3. ListNode* newnode = new ListNode{ x,NULL };
  4. if (pphead == NULL)
  5. {
  6. pphead = newnode;
  7. }
  8. else
  9. {
  10. ListNode* tail=  pphead;
  11. while(tail->next != NULL)
  12. {
  13. tail = tail->next;
  14. }
  15. tail->next = newnode;
  16. }
  17. }

则结果会变成：

没有任何输出。

原因是原本的指针phead是没有任何指向的，这个指针没有指向某一个地址，而是一个空指针，在函数传参的时候，如果参数pphead是一级指针，则pphead也是空指针，改变pphead，并不会影响到phead，所以最终一通操作下来，phead还是空指针，输出结果也就是空的。

下面再增加一些功能：

  1. #include<algorithm>
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. struct ListNode
  6. {
  7. int data;
  8. ListNode* next;//结构体指针
  9. };
  10. void Listprintf(ListNode* phead)
  11. {
  12. ListNode* cur=phead;
  13. while (cur != NULL)
  14. {
  15. cout << cur->data << "->";
  16. cur = cur->next;
  17. }
  18. cout << "NULL" << endl;
  19. }
  20. //尾插
  21. void Listpushback(ListNode** pphead, int x)
  22. {
  23. ListNode* newnode = new ListNode{ x,NULL };
  24. if (*pphead == NULL)
  25. {
  26. *pphead = newnode;
  27. }
  28. else
  29. {
  30. ListNode* tail=  *pphead;
  31. while(tail->next != NULL)
  32. {
  33. tail = tail->next;
  34. }
  35. tail->next = newnode;
  36. }
  37. }
  38. //头插
  39. void Listpushfront(ListNode** pphead, int x)
  40. {
  41. ListNode* newnode = new ListNode{ x,NULL };
  42. newnode->next = *pphead;
  43. *pphead = newnode;
  44. }
  45. //尾删
  46. void Listpopback(ListNode** pphead)
  47. {
  48. if (*pphead == NULL)
  49. {
  50. return;
  51. }
  52. if ((*pphead)->next == NULL)
  53. {
  54. delete(*pphead);
  55. *pphead = NULL;
  56. }
  57. else
  58. {
  59. ListNode* tail = *pphead;
  60. ListNode* prev = NULL;
  61. while (tail->next)
  62. {
  63. prev = tail;
  64. tail = tail->next;
  65. }
  66. delete(tail);
  67. tail = NULL;
  68. prev->next = NULL;
  69. }
  70. }
  71. //头删
  72. void Listpopfront(ListNode** pphead)
  73. {
  74. if (*pphead == NULL)
  75. {
  76. return;
  77. }
  78. else
  79. {
  80. ListNode* newnode = (*pphead)->next;
  81. delete(*pphead);
  82. *pphead = newnode;
  83. }
  84. }
  85. //查找元素，返回值是地址
  86. ListNode* Listfind(ListNode* phead, int x)
  87. {
  88. ListNode* cur = phead;
  89. while (cur)
  90. {
  91. if (cur->data == x)
  92. {
  93. return cur;
  94. }
  95. else
  96. {
  97. cur = cur->next;
  98. }
  99. }
  100. return NULL;
  101. }
  102. //插入元素，在pos的前一个位置插入
  103. //配合Listfind使用，具体使用见test_insert函数
  104. void Listinsert(ListNode** phead, ListNode* pos, int x)
  105. {
  106. ListNode* newnode = new ListNode{ x,NULL };
  107. if (*phead == pos)
  108. {
  109. newnode->next = (*phead);
  110. *phead = newnode;
  111. }
  112. else
  113. {
  114. ListNode* posprev = *phead;
  115. while (posprev->next != pos)
  116. {
  117. posprev = posprev->next;
  118. }
  119. posprev->next = newnode;
  120. newnode->next = pos;
  121. }
  122. }
  123. //单链表并不适合在前一个位置插入，因为运算较麻烦，会损失效率
  124. //包括c++中为单链表提供的库函数也只有一个insert_after而没有前一个位置插入
  125. //在后一个位置插入相对简单
  126. void Listinsert_after(ListNode** phead, ListNode* pos, int x)
  127. {
  128. ListNode* newnode = new ListNode{ x,NULL };
  129. newnode->next = pos->next;
  130. pos->next = newnode;
  131. }
  132. //删除指定位置的节点
  133. void Listerase(ListNode** pphead, ListNode* pos)
  134. {
  135. if (*pphead == pos)
  136. {
  137. *pphead = pos->next;
  138. delete(pos);
  139. }
  140. else
  141. {
  142. ListNode* prev = *pphead;
  143. while (prev->next!=pos)
  144. {
  145. prev = prev->next;
  146. }
  147. prev->next = pos->next;
  148. delete(pos);
  149. }
  150. }
  151. //释放链表
  152. void Listdestory(ListNode** pphead)
  153. {
  154. ListNode* cur = *pphead;
  155. while(cur)
  156. {
  157. ListNode* next = cur->next;
  158. delete(cur);
  159. cur = next;
  160. }
  161. *pphead = NULL;
  162. }
  163. void test_insert()
  164. {
  165. ListNode* phead = NULL;
  166. Listpushback(&phead, 1);
  167. Listpushback(&phead, 2);
  168. Listpushback(&phead, 3);
  169. Listprintf(phead);
  170. ListNode* pos = Listfind(phead, 2);
  171. if (pos != NULL)
  172. {
  173. Listinsert(&phead, pos, 20);
  174. }
  175. Listprintf(phead);
  176. pos = Listfind(phead, 2);
  177. if (pos != NULL)
  178. {
  179. Listinsert_after(&phead, pos, 20);
  180. }
  181. Listprintf(phead);
  182. Listdestory(&phead);
  183. }
  184. void test_find()
  185. {
  186. ListNode* phead = NULL;
  187. Listpushback(&phead, 1);
  188. Listpushback(&phead, 2);
  189. Listpushback(&phead, 3);
  190. Listprintf(phead);
  191. ListNode* pos = Listfind(phead, 2);
  192. if (pos != NULL)
  193. {
  194. pos->data = 20;//Listfind不仅能查找，也能借此修改，这也是函数返回地址的原因
  195. }
  196. Listprintf(phead);
  197. Listdestory(&phead);
  198. }
  199. void test_erase()
  200. {
  201. ListNode* phead = NULL;
  202. Listpushback(&phead, 1);
  203. Listpushback(&phead, 2);
  204. Listpushback(&phead, 3);
  205. Listprintf(phead);
  206. ListNode* pos = Listfind(phead, 2);
  207. if (pos != NULL)
  208. {
  209. Listerase(&phead, pos);
  210. }
  211. Listprintf(phead);
  212. Listdestory(&phead);
  213. }
  214. void test_pop_and_push()
  215. {
  216. ListNode* phead = NULL;
  217. Listpushback(&phead, 1);
  218. Listpushback(&phead, 2);
  219. Listpushback(&phead, 3);
  220. Listprintf(phead);
  221. Listpushfront(&phead, 1);
  222. Listpushfront(&phead, 2);
  223. Listpushfront(&phead, 3);
  224. Listprintf(phead);
  225. Listpopback(&phead);
  226. Listpopfront(&phead);
  227. Listprintf(phead);
  228. Listdestory(&phead);
  229. }
  230. int main()
  231. {
  232. //test_pop_and_push();
  233. test_find();
  234. //test_insert();
  235. //test_erase();
  236. return 0;
  237. }

test_pop_and_push()测试结果：

 test_find()测试结果：

 test_insert()测试结果：

 test_erase()测试结果：

 2.对链表进行一些操作

（1）删除等于给定值的所有节点。

例如：在一条链表中删除值为6的节点。

  1. #include<algorithm>
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. struct ListNode
  6. {
  7. int data;
  8. ListNode* next;//结构体指针
  9. };
  10. void Listprintf(ListNode* phead)
  11. {
  12. ListNode* cur=phead;
  13. while (cur != NULL)
  14. {
  15. cout << cur->data << "->";
  16. cur = cur->next;
  17. }
  18. cout << "NULL" << endl;
  19. }
  20. void Listpushback(ListNode** pphead, int x)
  21. {
  22. ListNode* newnode = new ListNode{ x,NULL };
  23. if (*pphead == NULL)
  24. {
  25. *pphead = newnode;
  26. }
  27. else
  28. {
  29. ListNode* tail=  *pphead;
  30. while(tail->next != NULL)
  31. {
  32. tail = tail->next;
  33. }
  34. tail->next = newnode;
  35. }
  36. }
  37. ListNode* creatlist()
  38. {
  39. ListNode* phead = NULL;
  40. Listpushback(&phead, 1);
  41. Listpushback(&phead, 9);
  42. Listpushback(&phead, 6);
  43. Listpushback(&phead, 8);
  44. Listpushback(&phead, 6);
  45. Listpushback(&phead, 2);
  46. Listpushback(&phead, 3);
  47. return phead;
  48. }
  49. ListNode* removeElements(ListNode* head, int x)
  50. {
  51. ListNode* prev = NULL;
  52. ListNode* cur = head;
  53. while (cur)
  54. {
  55. if (cur->data == x)
  56. {
  57. if (cur == head)//如果第一个元素就是要删除的，进行头删
  58. {
  59. head = cur->next;
  60. delete(cur);
  61. cur = head;
  62. }
  63. else
  64. {
  65. prev->next = cur->next;
  66. delete(cur);
  67. cur = prev->next;
  68. }
  69. }
  70. else
  71. {
  72. prev = cur;
  73. cur = cur->next;
  74. }
  75. }
  76. return head;
  77. }
  78. int main()
  79. {
  80. ListNode*phead = creatlist();//先创建一条链表
  81. Listprintf(phead);
  82. phead = removeElements(phead, 6);//删除值为6的节点
  83. Listprintf(phead);
  84. return 0;
  85. }

 自测结果：

 当然如果是一条全为6的链表也是可以完成删除的：

这里再说一下为什么删除元素和创建链表这两个函数的参数不是二级指针，因为这两个函数是要返回一个指针的。 

（2）翻转链表

比如：将1->2->3->4->5翻转为5->4->3->2->1

翻转链表的方式很多，这里只写两种作为参考：

第一种，翻转指针。

这种方法的逻辑是定义三个指针，一个用来纪录当前位置的前一个位置，一个用来纪录当前位置，一个用来纪录当前位置的后一个位置，再通过将当前位置指向下一个位置的指针修改为指向上一个位置，再往后迭代，以达到翻转链表的目的。

为什么要三个指针呢，因为将当前位置指向前一个位置之后，就找不到当前位置的下一个位置了，所以需要第三个指针来指向下一个位置。

代码部分由于只有测试函数不一样，其余代码差异不大，所以仅贴出测试函数部分：

  1. ListNode* reverseList(ListNode* head)
  2. {
  3. if (head == NULL)
  4. {
  5. return NULL;
  6. }
  7. ListNode* prev, * cur, * next;
  8. prev = NULL;
  9. cur = head;
  10. next = cur->next;
  11. while (cur)
  12. {
  13. cur->next = prev;//翻转指针
  14.  
  15. //往后迭代
  16. prev = cur;
  17. cur = next;
  18. if (next)//这里是因为当cur指向最后一个节点的时候，next就已经是NULL了，这个时候如果再执行next=next->next则会出现错误
  19. {
  20. next = next->next;
  21. }
  22. }
  23. return prev;
  24. }

自测结果：

测试结果（测试网站：牛客网）：

 第二种方式，创建新链表进行头插

这种方法的逻辑是将原链表中的节点取下来头插到新链表newlist中，同样的，需要三个指针，一个为NULL，即为新链表newlist，一个纪录原链表从头开始的地址，一个纪录下一个位置。将原链表第一个节点取下来对newlist进行头插，再取第二个第三个，往后迭代。

  1. ListNode* reverseList(ListNode* head)
  2. {
  3. ListNode* cur = head;
  4. ListNode* newlist = NULL;
  5. ListNode* next = NULL;
  6. while (cur)
  7. {
  8. next = cur->next;
  9. //头插
  10. cur->next = newlist;
  11. newlist = cur;
  12. //往后迭代
  13. cur = next;
  14. }
  15. return newlist;
  16. }

自测结果：

 测试结果（测试网站：牛客网）：

（3） 返回中间节点的地址

如果有两个中间节点，返回第二个中间节点。

这种操作比较简单，最容易想到的方法就是先遍历一次整个链表找出有几个节点，再遍历一次找出中间节点

但是如果要求只能遍历一次呢，所以这里不采用遍历两次的方法，而采用快慢指针的方式只遍历一次。

逻辑就是定义两个指针，一个走的更慢，一次走一步，另一个走的更快，一次走两步。

  1. ListNode* middleNode(ListNode* head)
  2. {
  3. ListNode* slow, * fast;
  4. slow = fast = head;
  5. while (fast && fast->next)
  6. {
  7. slow = slow->next;
  8. fast = fast->next->next;
  9. }
  10. return slow;
  11. }

自测结果：

（4）倒数第k个节点 

输入一个链表和k，输出从倒数第k个节点到最后一个。

思路和快慢指针相似，定义两个指针，一个指针先走k步。

  1. ListNode* findK(ListNode* head, int k)
  2. {
  3. ListNode* fast, * slow;
  4. fast = slow = head;
  5. while(k--)
  6. {
  7. if (fast == NULL)//如果当fast等于NULL时k仍不为0，则k大于链表长度
  8. {
  9. return NULL;
  10. }
  11. fast = fast->next;
  12. }
  13. while (fast)
  14. {
  15. fast = fast->next;
  16. slow = slow->next;
  17. }
  18. return slow;
  19. }

自测结果：

测试结果（测试网站：牛客网）：

 （5）合并有序链表

 思路比较简单，依次比较链表中的节点，将较小的节点尾插到新链表。

当然还有一种做法是将一个链表直接插入到另一个链表中，这种方式画图画起来倒是简单，但是实际写起来很麻烦，这里不推荐这种写法，也不会写这种。

  1. ListNode* mergeTwoList(ListNode* l1, ListNode* l2)
  2. {
  3. if (l1 == NULL)//如果一个链表为空，则返回另一个
  4. {
  5. return l2;
  6. }
  7. if (l2 == NULL)
  8. {
  9. return l1;
  10. }
  11. ListNode* head = NULL;
  12. ListNode* tail = NULL;
  13. while (l1 && l2)
  14. {
  15. if (l1->data < l2->data)
  16. {
  17. if (head == NULL)
  18. {
  19. head = tail =l1;
  20. }
  21. else
  22. {
  23. tail->next = l1;
  24. tail = l1;
  25. }
  26. l1 = l1->next;
  27. }
  28. else
  29. {
  30. if (head == NULL)
  31. {
  32. head = tail = l2;
  33. }
  34. else
  35. {
  36. tail->next = l2;
  37. tail = l2;
  38. }
  39. l2 = l2->next;
  40. }
  41. }
  42. if (l1)
  43. {
  44. tail->next = l1;
  45. }
  46. if(l2)
  47. {
  48. tail->next = l2;
  49. }
  50. return head;
  51. }

自测结果：

我这里是将两条1->2->3->4->5->6的链表合并。

测试结果（测试网站：牛客网）：

 可以看到这种不带哨兵位的写法也还是比较麻烦，要判断头为不为空，所以下面再写一种带哨兵位的写法。

带哨兵位（也叫带头）就是我们去给链表多定义一个头结点，这个节点不存储有效数据。

  1. ListNode* mergeTwoList(ListNode* l1, ListNode* l2)
  2. {
  3. if (l1 == NULL)//如果一个链表为空，则返回另一个
  4. {
  5. return l2;
  6. }
  7. if (l2 == NULL)
  8. {
  9. return l1;
  10. }
  11. ListNode* head = NULL, * tail = NULL;
  12. head = tail = new ListNode;//哨兵位的头结点
  13. while (l1 && l2)
  14. {
  15. if (l1->data < l2->data)
  16. {
  17.     tail->next = l1;
  18.     tail = l1;
  19.     l1 = l1->next;
  20.  }
  21. else
  22. {
  23. tail->next = l2;
  24. tail = l2;
  25. l2 = l2->next;
  26. }
  27. }
  28. if (l1)
  29. {
  30. tail->next = l1;
  31. }
  32. if (l2)
  33. {
  34. tail->next = l2;
  35. }
  36. ListNode* list = head->next;
  37. delete(head);
  38. return list;
  39. }

自测结果：

测试结果（测试网站：牛客网）：

 （6）分割链表

 给定一个值x，将所有小于x的节点排在其余节点之前，且不能改变原来的数据顺序，返回重新排列后的链表头指针。

思路：定义两条链表，一条将小于x的所有节点按照原顺序连接成链表，另一条将大于x的所有节点按照原顺序连接成链表，最后再合起来。

  1. ListNode* partition(ListNode* phead, int x)
  2. {
  3. ListNode* lesshead, * lesstail, * greaterhead, * greatertail;
  4.  
  5. lesshead = lesstail = new ListNode;//定义一个哨兵位头结点，方便尾插
  6. lesstail->next = NULL;
  7. greaterhead = greatertail = new ListNode;
  8. greatertail->next = NULL;
  9.  
  10. ListNode* cur = phead;
  11. while (cur)
  12. {
  13. if (cur->data < x)
  14. {
  15. lesstail->next = cur;
  16. lesstail = cur;
  17. }
  18. else
  19. {
  20. greatertail->next = cur;
  21. greatertail = cur;
  22. }
  23. cur = cur->next;
  24. }
  25. lesstail->next = greaterhead->next;
  26. greatertail->next = NULL;//举个例子，这样一条链表:1->4->15->5,现在给的x是6，那么排序后15应该在最后，正因如此，重新排序后15的next是没变的，仍然指向5，不手动将next改为NULL，就会成环，无限排下去。
  28. ListNode* newhead = lesshead->next;
  29. delete(lesshead);
  30. delete(greaterhead);
  31. return newhead;
  32. }

自测结果：

测试结果（测试网站：力扣）：

（7）链表回文

判断链表是否回文。

思路，先找到一条链表的中点，将后半段逆置，设置两个指针，一个从头开始，一个从逆置后的头开始，逐个判断直到最后。

图：

节点奇数个：

节点偶数个：

代码：

  1. ListNode* middleNode(ListNode* head)
  2. {
  3. ListNode* slow, * fast;
  4. slow = fast = head;
  5. while (fast && fast->next)
  6. {
  7. slow = slow->next;
  8. fast = fast->next->next;
  9. }
  10. return slow;
  11. }
  12. ListNode* reverseList(ListNode* head)
  13. {
  14. ListNode* cur = head;
  15. ListNode* newlist = NULL;
  16. ListNode* next = NULL;
  17. while (cur)
  18. {
  19. next = cur->next;
  20. //头插
  21. cur->next = newlist;
  22. newlist = cur;
  23. //往后迭代
  24. cur = next;
  25. }
  26. return newlist;
  27. }
  28. bool check(ListNode* head)
  29. {
  30. ListNode* mid = middleNode(head);
  31. ListNode* rhead = reverseList(mid);
  32. ListNode* curHead = head;
  33. ListNode* curRhead = rhead;
  34. while(curHead&&curRhead)
  35. {
  36. if (curHead->data != curRhead->data)
  37. return false;
  38. else
  39. {
  40. curHead = curHead->next;
  41. curRhead = curRhead->next;
  42. }
  43. }
  44. return true;
  45. }

自测结果：

测试结果（测试网站：牛客网）： 

 

（8）链表相交 

 给两个单链表的头结点，找出并返回两个单链表相交的起始节点，没有交点则返回null。

最简单粗暴的思路就是将A链表的每个节点和B链表的每个节点挨着挨着比较，这里不使用这一种。 

还有一种思路就是，找到A和B的尾结点对比，如果一样则有交点，如果不一样则没有交点，有交点的情况下又该怎样找到相交的起始节点？

如果两条链表在相交之前的节点个数一样的话，那么找到相交的起始节点就很简单，定义两个指针同时向前走直到相等即可，所以我们在找链表A和B的尾结点的时候，同时纪录下A和B的长度，用长的减去短的得到一个数x，再分别为两条链表定义头指针，让长的那条链表的头指针先走x步，那么就可以当做是在相交之前节点数一样了。

  1. ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) 
  2. {
  3.         if(pHead1==NULL)
  4.         {
  5.             return NULL;
  6.         }
  7.         if(pHead2==NULL)
  8.         {
  9.             return NULL;
  10.         }
  11.         ListNode* tail1=pHead1;
  12.         ListNode* tail2=pHead2;
  13.         int len1=1,len2=1;
  14.         while(tail1->next)
  15.         {
  16.             len1++;
  17.             tail1=tail1->next;
  18.         }
  19.         while(tail2->next)
  20.         {
  21.             len2++;
  22.             tail2=tail2->next;
  23.         }
  24.         if(tail1!=tail2)//不相交
  25.         {
  26.             return NULL;
  27.         }
  28.         int gap=abs(len1-len2);
  29.         ListNode* longlist=pHead1;
  30.         ListNode* shortlist=pHead2;
  31.         if(len1<len2)
  32.         {
  33.             longlist=pHead2;
  34.             shortlist=pHead1;
  35.         }
  36.         while(gap--)//长的先走差距步，再同时走找交点
  37.         {
  38.             longlist=longlist->next;
  39.         }
  40.         while(longlist!=shortlist)
  41.         {
  42.             longlist=longlist->next;
  43.             shortlist=shortlist->next;
  44.         }
  45.         return longlist;
  46.     }

测试结果（测试网站：牛客网）：

 （9）环形链表

判断链表是否带环，并且返回环的入口节点。

判断是否带环的思路比较简单，定义两个指针，一个走得快，一次走两步，一个走得慢，一次走一步，如果不带环，那么走得快的最终会走到NULL，如果带环，那么走得快的会和走得慢的相遇。

要找环的入口节点，也需要定义两个指针，一个从链表头开始，一个从快慢指针相遇的位置开始，他们同时出发，当这两个指针相遇时，所在的位置就是入口节点。

这里做简单的证明，假设链表头到入口节点距离是L，快慢指针相遇的位置meetnode距离入口节点为x

 假设C是环的长度，当快慢指针相遇时，快指针走的距离是L+N*C+x，N是快指针走的圈数，慢指针走的距离是L+x，因为快指针一次走两步，慢指针一次走一步，所以快指针走的距离是慢指针的两倍，所以有：

L+N*C+x=2（L+x）

得到：

L+x=N*C

L=（N-1）*C+C-x

其中C-x即为meetnode到入口节点的距离，所以当头指针和从meetnode出发的指针相遇时，头指针走了L，从meetnode出发的指针走了C-x，相遇点即为入口节点。

代码：

  1. ListNode* EntryNodeOfLoop(ListNode* pHead) {
  2.         ListNode*fast=pHead;
  3.         ListNode*slow=pHead;
  4.         while(fast&&fast->next)
  5.         {
  6.             slow=slow->next;
  7.             fast=fast->next->next;
  8.             if(fast==slow)
  9.             {
  10.                 ListNode*meet=fast;
  11.                 while(meet!=pHead)
  12.                 {
  13.                     meet=meet->next;
  14.                     pHead=pHead->next;
  15.                 }
  16.                 return pHead;
  17.             }
  18.         }
  19.         return NULL;
  20.     }

测试结果（测试网站：牛客网）：

这里再说下还有另一种处理方式，就是将meetnode作为链表的尾，meetnode的next作为链表的头，就转化成了两条相交链表找第一个相交节点的问题，这种方式写起来会麻烦一些，这里也不做代码实现。

二，双向链表

 双向链表的一个数据所在的内存块是被分成了三部分，除了像单链表那样一部分存储数据，一部分存储下一个数据的地址之外，还要有一部分来存储上一个数据的地址。

在代码中如下：

  1. struct ListNode
  2. {
  3. int data;
  4. ListNode* next;//结构体指针
  5. ListNode* prev;
  6. };

双向链表的结构：

其中最常用的是双向带头（哨兵位）循环链表

 

后面的代码中双向链表也都是这种。

1.增删查改

  这里多说一句，很多人都会下意识的认为在带哨兵位的链表中，哨兵位是一条链表开始的位置，但是实际上哨兵位的下一位才是。

  1. #include<algorithm>
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. struct ListNode
  6. {
  7. int data;
  8. ListNode* next;//结构体指针
  9. ListNode* prev;
  10. };
  11. ListNode* Initlist()//初始化双向带头（哨兵）循环链表
  12. {
  13. ListNode* phead=new ListNode;
  14. phead->next = phead;
  15. phead->prev = phead;//定义一个哨兵位，自己的next和prev指向自己
  16. return phead;
  17. }
  18. void pushback(ListNode* phead,int x)//尾插
  19. {
  20. ListNode* tail = phead->prev;//循环链表，哨兵位的前一个就是尾
  21. ListNode* newhead = new ListNode;
  22. newhead->data = x;
  23.  
  24. newhead->next = phead;
  25. newhead->prev = tail;
  26. tail->next = newhead;
  27. phead->prev = newhead;
  28. }
  29. void popback(ListNode* phead)//尾删
  30. {
  31. if (phead->next == phead)//链表为空，不能再删了
  32. return;
  33.  
  34. ListNode* tail = phead->prev;
  35. ListNode* tailprev = tail->prev;
  36.  
  37. tailprev->next = phead;
  38. phead->prev = tailprev;
  39.  
  40. delete(tail);
  41. }
  42. void pushfront(ListNode* phead,int x)//头插
  43. {
  44. ListNode* next = phead->next;
  45. ListNode* newnode = new ListNode;
  46. newnode->data = x;
  47.  
  48. phead->next = newnode;
  49. newnode->prev = phead;
  50. newnode->next = next;
  51. next->prev = newnode;
  52. }
  53. void popfront(ListNode* phead)//头删
  54. {
  55. if (phead->next == phead)//链表为空，不能再删了
  56. return;
  57.  
  58. ListNode* next = phead->next;
  59. ListNode* dnext = next->next;
  60.  
  61. phead->next = dnext;
  62. dnext->prev = phead;
  63.  
  64. delete(next);
  65. }
  66. ListNode* listFind(ListNode* phead, int x)//查找
  67. {
  68. ListNode* cur = phead->next;
  69. while (cur != phead)
  70. {
  71. if (cur->data == x)
  72. return cur;
  73. cur = cur->next;
  74. }
  75. return NULL;
  76. }
  77. void insertList(ListNode* pos, int x)//指定位置插入
  78. {
  79. ListNode* prev = pos->prev;
  80. ListNode* newnode = new ListNode;
  81. newnode->data = x;
  82.  
  83. prev->next = newnode;
  84. newnode->prev = prev;
  85. newnode->next = pos;
  86. pos->prev = newnode;
  87. }
  88. void eraseList(ListNode* pos)//指定位置删除
  89. {
  90. ListNode* posNext = pos->next;
  91. ListNode* posPrev = pos->prev;
  92.  
  93. posNext->prev = posPrev;
  94. posPrev->next = posNext;
  95. delete(pos);
  96. pos = NULL;
  97. }
  98. void printlist(ListNode* phead)
  99. {
  100. ListNode* cur = phead->next;
  101. while (cur != phead)
  102. {
  103. cout << cur->data << " ";
  104. cur = cur->next;
  105. }
  106. cout << endl;
  107. }
  108. void test_pop_push()
  109. {
  110. ListNode* phead = Initlist();
  111. pushback(phead, 1);
  112. pushback(phead, 2);
  113. pushback(phead, 3);
  114. printlist(phead);
  115. popback(phead);
  116. popback(phead);
  117. printlist(phead);
  118. pushfront(phead, 1);
  119. pushfront(phead, 2);
  120. pushfront(phead, 3);
  121. printlist(phead);
  122. popfront(phead);
  123. popfront(phead);
  124. printlist(phead);
  125. }
  126. void test_find_insert_erase()
  127. {
  128. ListNode* phead = Initlist();
  129. pushback(phead, 1);
  130. pushback(phead, 2);
  131. pushback(phead, 3);
  132. printlist(phead);
  133. ListNode* p = listFind(phead, 2);
  134. insertList(p, 20);
  135. printlist(phead);
  136. p = listFind(phead, 20);
  137. eraseList(p);
  138. printlist(phead);
  139. }
  140. int main()
  141. {
  142. //test_pop_push();
  143. test_find_insert_erase();
  144. return 0;
  145. }

test_pop_push()测试结果：

test_find_insert_erase()测试结果：

其中最重要的是insert()和erase()函数，在双向带头循环链表中，这两个函数是可以分别和头尾插，头尾删函数复用的，即可以修改成：

  1. void pushback(ListNode* phead,int x)//尾插
  2. {
  3. insertList(phead,x);
  4. }
  5. void popback(ListNode* phead)//尾删
  6. {
  7. if (phead->next == phead)//链表为空，不能再删了
  8. return;
  9.  
  10. eraseList(phead->prev);
  11. }
  12. void pushfront(ListNode* phead,int x)//头插
  13. {
  14. insertList(phead->next, x);
  15. }
  16. void popfront(ListNode* phead)//头删
  17. {
  18. if (phead->next == phead)//链表为空，不能再删了
  19. return;
  20.  
  21. eraseList(phead->next);
  22. }

最后再说一下为什么双向链表中的函数的参数是一级指针而不是像之前单链表那样是二级指针的问题 ，这是因为在我写的双向链表中是带了头的，也就是带了哨兵位，所以不需要考虑传进来的是空指针，改变形参不会影响变量的问题，而在我写单链表的时候是没有带头的。

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览47303 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪