:::info 前言：这篇文章，打算详细记录下链表的相关知识，毕竟是基础中的基础。首先是先记录下在一开始学习过程中的些许疑惑/C的遗忘，然后记录各种代码（实验报告代码，单链表各种操作代码总结，循环链表代码，双向链表代码） :::

实验要求

1、创建一个带头结点的单链表（头指针为head），且遍历此链表（输出链表中各结点的值）； 2、查找单链表中的第i个结点，并输出结点元素的值；

3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入);

4、删除单链表中的第j个结点；

*5、将单链表中的各结点就地逆序（不允许另建一个链表）；

概念理解

链表数据结构

链表是一种数据结构，和数组同级。之前JAVA里面的ArrayList数据结构，其实现原理是数组，而JAVA的LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显，其实C/C++抑或是JAVA这些数据结构都一样——地址……引用……

单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。
C 链表(单、循环、双向)设计及操作 - 图1
上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。

下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。
C 链表(单、循环、双向)设计及操作 - 图2
节点（Node）是由一个需要储存的对象及对下一个节点的引用组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：
C 链表(单、循环、双向)设计及操作 - 图3

关于链表的指向

【1】何为指向？

个人觉得链表的相关问题及操作就是理解链表的“指向”这么个概念，先明确以下几点

  • 每个节点的next用来存放下一个节点的“地址”
  • 每个节点的自身就是地址，相当于C语言中数组的数组名就是本数组的地址

【2】谁指向谁？

总结：做题用下面总结的方法，绝对好使
huaji1558a846ddf2e12b.jpeg

  • 读的时候：从左往右读，一般左边是某某的next域，右边是具体的结点
  • 画的时候：在图中表示为等号左边指向等号右边


例子：
① node.next = prev.next;
② prev.next = node
读法：
①“node的next指向prev的下一个结点”
（用指针的概念通俗地说，其实就是prev的下一个结点的地址由prev的指针域里面赋值给了node的next指针域里面）
②“prev的next指向node这个结点”
（还可以这么说：将node赋值给prev的next，也就是说prev的下一个结点是node）

C 链表(单、循环、双向)设计及操作 - 图5
C 链表(单、循环、双向)设计及操作 - 图6
C 链表(单、循环、双向)设计及操作 - 图7

【3】指向错位？

关注第一个元素节点是不是head，因为有的链表不声明头节点（head），直接就是第一个结点就是元素结点

关于p=L的理解

写代码的时候，还经常遇到下面的情况
image.png
p、L就是指向结点的指针类型，将L的值赋给p，也就是p、L指向同一个结点。具体理解可以用下面一个例子来说明：
下面图片这个函数就是在一个单链表中，功能就是指定i位置插入e值。下图箭头处如果TraverseList返回的是p那么得出的链表结果就是从插入的那个元素往后这样一个部分链表，返回的是L就是想要的结果，p的功能有点类似在L的中间做了手脚……
image.png

各种代码

实验报告代码

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. typedef struct LNode {
  5.     int data;
  6.     struct LNode *next;
  7. }Lnode, *LinkList;
  9. LinkList L;
  11. void InitList(LinkList &L) {
  12.     L = new LNode;
  13.     L->next = NULL;
  14. }
  16. void CreateList_H(LinkList &L) {
  17.     InitList(L);
  18.     int n;
  19.     cout << "请输入要使用前插法插入的元素个数：";
  20.     cin >> n;
  21.     for (int i = 0; i < n; i++){
  22.         LNode *p = new LNode;
  23.         cin >> p->data;
  24.         p->next = L->next;
  25.         L->next = p;
  26.     }
  27. }
  28. void TraverseList(LinkList &L){
  29.     LNode *p = new LNode;
  30.     p = L->next;
  31.     cout << "此链表打印的结果为："<<"\n";
  32.     while (p != NULL){
  33.         cout << p->data << " ";
  34.         p = p->next;
  35.     }
  36.     cout << "\n";
  37. }
  38. void GetElem(LinkList &L) {
  39.     int n;
  40.     cout << "请输入要查询的链表中第i个数：";
  41.     cin >> n;
  42.     LNode *p = new LNode;
  43.     p = L;
  44.     for (int i = 0; i < n;i++){
  45.         p = p->next;
  46.     }
  47.     cout << "查询的结果为：" << p->data<<"\n";
  48. }
  49. void ListInsert(LinkList &L){
  50.     LNode *p = new LNode;
  51.     p = L;
  52.     int n;
  53.     int e;
  54.     cout << "请分别输入要在第n个位置插入的e值：";
  55.     cin >> n>> e ;
  56.     for (int i = 0; i < n;i++) {
  57.         if (n == i+1){
  58.             LNode *temp = new LNode;
  59.             temp->data = e;
  60.             temp->next = p->next;
  61.             p->next = temp;
  62.             break;
  63.         }
  64.         p = p->next;
  65.     }
  66.     TraverseList(L); // 直接返回L就可以了，之前返回p是不可以的！！！唉，大意了~
  67. }
  68. void ListDelete(LinkList &L){
  69.     cout << "请输入要删除的第j个位置的j值：";
  70.     LNode *p = new LNode;
  71.     p = L;
  72.     int j;
  73.     cin >> j;
  74.     for (int i = 0; i < j;i++) {
  75.         if (j == i+1) {
  76.             p->next = p->next->next;
  77.             break;
  78.         }
  79.         p = p->next;
  80.     }
  81.     TraverseList(L);
  82. }
  83. void ReverseList(LinkList &L) {
  84.     LNode *p = L->next;             
  85.     L->next = NULL;                
  86.     while(p)                        
  87.     {
  88.         LNode *q = p->next;         
  89.         p->next = L->next;          
  90.         L->next = p;                
  91.         p = q;                      
  92.     }
  93.     cout << "通过逆置之后……";
  94.     TraverseList(L);
  95. }
  97. int main() {
  98.     LNode *test = new LNode;
  99.     CreateList_H(test);//1
  100.     TraverseList(test);//1
  101.     GetElem(test);//2
  102.     ListInsert(test);//3
  103.     ListDelete(test);//4
  104.     ReverseList(test);//5
  105. }

单链表各种操作代码总结

  • [x] 单链表存储形式

    1. typedef struct LNode {
    2.   int data; //数据域
    3.   struct LNode *next; //指针域
    4. }Lnode, *LinkList; //LinkList为指向结构体LNode的指针类型

  • [x] 初始化

  • 创建：前插法
  • 创建：后插法
  • 取值
  • 插值
  • 删除
  • 打印
  • 逆置

逆置多用前插的思想

  1. void ReverseList(LinkList &L) {
  2.     LNode *p = L->next;             
  3.     L->next = NULL;                
  4.     while(p) {
  5.         LinkList q = p->next;         
  6.         p->next = L->next;          
  7.         L->next = p;                
  8.         p = q;                      
  9.     }
  10. }

所有操作如下

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. /**
  5.  * 单链表
  6.  * 
  7.  * 链表的基本操作：初始化、创建（前插、后插）、取值、查找、插值、删除、打印、逆置
  8.  */
  11. /* 单链表的存储结构 */
  12. typedef struct LNode {
  13.     int data; //数据域
  14.     struct LNode *next; //指针域
  15. }Lnode, *LinkList; //LinkList为指向结构体LNode的指针类型
  18. /* 初始化链表 */
  19. void InitList(LinkList &L) {
  20.     L = new LNode;
  21.     L->next = NULL;
  22. }
  24. /* 创建：前插 */
  25. void CreateList_H(LinkList &L, int n) {
  26.     InitList(L);
  27.     for (int i = 0; i < n; i++){
  28.         LNode *p = new LNode;
  29.         cin >> p->data;
  30.         p->next = L->next;
  31.         L->next = p;
  32.     }
  33. }
  35. /* 创建：后插 */
  36. void CreateList_R(LinkList &L, int n) {
  37.     cout << "请输入" << n << "个数字"<< "\n";
  38.     InitList(L);
  39.     // 定义一个在下面循环用来一直操作所加元素的结点p来指向头结点L
  40.     LinkList p = L;
  41.     for (int i = 0; i < n;i++) {
  42.         LinkList q = new Lnode;
  43.         q->next = NULL;
  44.         cin >> q->data;
  45.         p->next = q;
  46.         p = q; //为了下一次
  47.     }
  48. }
  50. /* 取值 */
  51. void GetElem(LinkList &L, int n) {
  52.     LinkList p = L;
  53.     for (int i = 0; i < n;i++){
  54.         p = p->next;
  55.     }
  56.     cout <<n<<"的值为：" << p->data<<"\n"<<"\n";
  57. }
  59. /* 查找 */
  60. void SearchElem(LinkList &L, int ele) {
  61.     LinkList p = L;
  62.     int count = 0;
  63.     while (p->data != ele) {
  64.         p = p->next;
  65.         count++;
  66.     }
  67.     cout <<ele<<"这个值的索引位置是："<< count<<"\n";
  68. }
  70. /* 插值：在第n个位置插入ele值*/
  71. void ListInsert(LinkList &L, int n, int ele){
  72.     LinkList p = L;
  73.     for (int i = 0; i < n;i++) {
  74.         if (n == i+1){
  75.             LinkList temp = new LNode;
  76.             temp->data = ele;
  77.             temp->next = p->next;
  78.             p->next = temp;
  79.             break;
  80.         }
  81.         p = p->next;
  82.     }
  83.     TraverseList(L); 
  84. }
  86. /* 删除：删除第j个位置的值 */
  87. void ListDelete(LinkList &L, int j){
  88.     LinkList p = L;
  89.     for (int i = 0; i < j;i++) {
  90.         if (j == i+1) {
  91.             p->next = p->next->next;
  92.             break;
  93.         }
  94.         p = p->next;
  95.     }
  96.     TraverseList(L);
  97. }
  99. /* 打印 */
  100. void TraverseList(LinkList & L){
  101.         LNode *p = new LNode;
  102.         p = L->next;
  103.         cout << "此链表打印的结果为："
  104.              << "\n";
  105.         while (p != NULL)
  106.         {
  107.             cout << p->data << " ";
  108.             p = p->next;
  109.         }
  110.         cout << "\n";
  111. }
  112. /* 逆置 */
  113. void ReverseList(LinkList &L) {
  114.     LNode *p = L->next;             
  115.     L->next = NULL;                
  116.     while(p)                        
  117.     {
  118.         LNode *q = p->next;         
  119.         p->next = L->next;          
  120.         L->next = p;                
  121.         p = q;                      
  122.     }
  123.     cout << "通过逆置之后……";
  124.     TraverseList(L);
  125. }
  127. int main() {
  128.     // LNode *test = new LNode;
  129.     LinkList test;
  130.     // struct LNode *test;
  131.     CreateList_R(test,4);
  132.     SearchElem(test, 3);
  133.     // cout << GetEle(test, 2);
  134.     // TraverseList(test);
  135.     // GetElem(test,2);
  136.     // ListInsert(test);
  137.     // ListDelete(test);
  138.     // ReverseList(test);
  139. }

循环链表代码

  • 循环链表其实只需要注意最后一个结点所指向的下一个结点为头结点L就好了
    还要注意头结点存不存元素
     还有判断的时候条件不是单链表那样判断是否为空了，而是是否为头结点的值了 ```cpp

    include

    using namespace std;

/**

  • 循环链表
  • 循环链表其实只需要注意最后一个结点所指向的下一个结点为头结点L就好了
  • 还要注意头结点存不存元素
  • 还有判断的时候条件不是单链表那样判断是否为空了，而是是否为头结点的值了 */

/ 定义一个单链表 / typedef struct LNode { int data; struct LNode next; }Lnode, LinkList;

/**

  • 初始化单链表 */ void InitList(LinkList &L) { L = new LNode; L->next = NULL; }

/**

  • 初始化单链表并将其变成循环链表 */

void CircleList(LinkList &L, int n) { InitList(L); // 初始化第一个结点的值 L->data = 1; LinkList p = L; for (int i = 2; i <= n; i++) { LinkList temp = new Lnode; temp->data = i; if (i == n) { temp->next = L; p->next = temp; break; } temp->next = NULL; p->next = temp; p = p->next; } }

/**

  • 打印输出用来测试是否为循环链表 */ void PrintList(LinkList &L, int n) { LinkList p = L; for (int i = 0; i < n;i++) {
    1.  cout << p->data << " ";
    2.  p = p->next;
    } }

int main() { LinkList test; CircleList(test,5); PrintList(test, 12); }

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1484158/1618307254729-8f60bc5d-be41-47fe-a2ad-466715cc740e.png#align=left&display=inline&height=45&margin=%5Bobject%20Object%5D&name=image.png&originHeight=90&originWidth=596&size=22406&status=done&style=none&width=298)
  2. <a name="oJUke"></a>
  3. ### 双向链表代码
  5. - 双向链表从某种意义上来说，更加简单了，因为可操作的“指向更多了”，但正因为这样，所以每次指向操作之后，检查一下有没有“落单的指向”
  6. - 删除某个结点的时候，一定要记得删除哪个结点，就操作哪个结点
  7. ```cpp
  8. #include<bits/stdc++.h>
  9. using namespace std;
  11. /**
  12.  * 双向链表
  13.  */
  16. /* 双向链表的存储结构 */
  17. typedef struct DuLNode {
  18.     int data; 
  19.     struct DuLNode *prior; 
  20.     struct DuLNode *next; 
  21. }DuLnode, *DuLinkList; 
  23. /* 双向链表的初始化 */
  24. void InitDuLinkList(DuLinkList &L) {
  25.     L = new DuLNode;
  26.     L->prior = NULL;
  27.     L->next = NULL;
  28. }
  30. int main() {
  31.     DuLinkList L;
  32.     InitDuLinkList(L);
  33.     // 初始化初始节点值为100
  34.     L->data = 100;
  35.     // 在L结点前面插值50
  36.     DuLinkList L_prior;
  37.     L_prior->data = 50;
  38.     L_prior->next = L;
  39.     L->prior = NULL;
  40.     L->prior = L_prior;
  41.     // 在L结点后面插值150
  42.     DuLinkList L_next;
  43.     L_next->data = 150;
  44.     L_next->prior = L;
  45.     L_next->next = NULL;
  46.     L->next = L_next;
  47.     cout << L_prior->data << " " << L_prior->next->data << " " << L_prior->next->next->data<<"\n";
  48.     // 在50和100之间插值75（只操作L结点）
  49.     DuLinkList L_prior_L;
  50.     L_prior_L->data = 75;
  51.     L_prior_L->prior = L->prior;
  52.     L->prior->next = L_prior_L;
  53.     L_prior_L->next = L;
  54.     L->prior = L_prior_L;
  55.     cout << L->prior->prior->data << " " << L->prior->data << " " << L->data <<" "<< L->next->data<<"\n";
  56.     // 删除75这个值的结点(记住一点，删除哪个结点就操作哪个结点)
  57.     L_prior_L->next->prior = L_prior_L->prior;
  58.     L_prior_L->prior->next = L_prior_L->next;
  59.     cout << L->prior->data << " " << L->data << " " << L->next->data << "\n";
  60. }

image.png

参考