C语言之链表：单向链表，循环链表，双向链表

﹏ヽ暗。殇╰゛Y 2022-11-20 01:53 263阅读 0赞

## C语言之链表：单向链表，循环链表，双向链表 ##

提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。

对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存  
的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败

而对于链表来说，他对内存空间的要求就不会有那么高，它并不需要一块连续的内存空间，只要内存空间充足，即使内存空间存在碎片，只要碎片的大小足够存储一个链表节点的数据，该碎片的空间都有可能被分配，链表通过指针或者引用的方式将一组零散的空间串联起来使用。所以如果一个链表需要100M的空间，但是如果内存空间充足，但是没有一个连续的空间大于100M，也不会影响链表的空间分配。

**数组作为一个顺序储存方式的数据结构，可是有大作为的，它的灵活使用为我们的程序设计带来了大量的便利；  
但是，数组最大的缺点就是我们的插入和删除时需要移动大量的元素，所以呢，大量的消耗时间，以及冗余度难以接受了。**

**相比起数组，链表解决了数组不方便移动，插入，删除元素的弊端，但相应的，链表付出了更加大的内存牺牲换来的这些功能的实现。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]  
对于链式存储结构，一般情况下我们遇到最多且最常用的大概有单向链表，双向链表，循环链表三种。  
链表是通过指针或者引用将分散的内存块链接在一起，我们把串联在链表上的每一个内存块称为链表的节点。

**1. 单向链表**  
在链表结构中，每个节点仅存储本身需要存储的数据和下一个节点地址的这种链表结构，我们称为单链表结构，其示意图如下：  
![在这里插入图片描述][20201122165209818.png_pic_center]  
如图所示，在单链表中的每个节点中，除了数据区域外，还有一个区域存储了当前节点的下一节点的地址，我们把这个记录下个结点地址的指针或引用叫作后继指针或引用Next。

在我们的单链表结构中，有两个节点比较特殊，那就是第一个节点和最后一个节点。在链式存储结构中，我们将第一个节点称为头结点，将最后一个节点称为尾节点。头节点记录链表的起始地址，有了这个地址，我们就可以遍历整个链表。尾节点的后继指针或者引用不是指向一个具体的节点，而是指向一个空地址NULL，从而表示该节点为链表的尾节点。

与数组一样，链表也支持数据的**插入、查找、删除。**

但是我们都知道，数组在进行数据的插入，删除操作时，为了保证内存数据的连续性，往往需要做大量的数据搬移工作，所以时间复杂度是**O(n)**。而在链表中插入或删除数据时，因为链表结构中的节点并不需要连续的存储空间，所以在链表中进行数据的插入和删除时并不需要搬移节点。对于链表的删除和插入操作，我们只需要调整相邻节点的后继指针即可，所以对应的时间复杂度是**O(1)**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 2]  
和数组相比，链表如果需要访问第k个元素，就没有数组那么简单了。因为数组的内存数据是连续的，当我们需要访问第k个元素时，通过基地址（base\_address）和数据类型大小就可以随机访问到数据所在的内存地址。

array[k]_address=base_address+k*data_type_size;

但是对于链表来讲，因为链表中各个节点的数据在内存中时分散的，不像数组那样是连续的存储空间，所以要访问链表中的第k个元素，只能从头结点开始，根据节点间的后继指针或引用逐一遍历，直到找到相应的节点，所以链表的随机访问的性能没有数组好，时间复杂度为O(n)。

**对于一个单链表的结点定义，可以代码描述成：**

//定义结点类型
    typedef struct Node {
        
        int data;       
        //数据类型，你可以把int型的data换成任意数据类型，包括结构体    struct等复合类型
        struct Node *next;          //单链表的指针域
    } Node,*LinkedList;  
    //Node表示结点的类型，LinkedList表示指向Node结点类型的指针类型

**链表的初始化：**

初始化主要完成以下工作：创建一个单链表的前置节点并向后逐步添加节点，一般指的是申请结点的空间，同时对一个结点赋空值(NULL)，其代码可以表示为：

LinkedList listinit(){
        
        Node *L;
        L=(Node*)malloc(sizeof(Node));      //开辟空间 
        if(L==NULL){
                             //判断是否开辟空间失败，这一步很有必要
            printf("申请空间失败");
            //exit(0);                  //开辟空间失败可以考虑直接结束程序
        }
        L->next=NULL;       //指针指向空
    }

**注意：**  
一定要判断是否开辟空间失败，否则生产中由于未知的情况造成空间开辟失败，仍然在继续执行代码，后果将不堪设想啦，因此养成这样的判断是很有必要的。

**头插入法创建单链表：**

利用指针指向下一个结点元素的方式进行逐个创建，使用头插入法最终得到的结果是逆序的。如图所示：

//头插法建立单链表
    LinkedList LinkedListCreatH() {
        
        Node *L;
        L = (Node *)malloc(sizeof(Node));   //申请头结点空间
        L->next = NULL;                      //初始化一个空链表
      
        int x;                         //x为链表数据域中的数据
        while(scanf("%d",&x) != EOF) {
        
            Node *p;
            p = (Node *)malloc(sizeof(Node));   //申请新的结点
            p->data = x;                     //结点数据域赋值
            p->next = L->next;     //将结点插入到表头L-->|2|-->|1|-->NULL
            L->next = p;
        }
        return L;
    }

**尾插入法创建单链表：**  
如图所示为尾插入法的创建过程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 4]  
头插法生成的链表中，结点的次序和输入数据的顺序不一致。若希望两者次序一致，则需要尾插法。  
该方法是将新结点逐个插入到当前链表的表尾上，为此必须增加一个尾指针r, 使其始终指向当前链表的尾结点，代码如下：

//尾插法建立单链表
      
    LinkedList LinkedListCreatT() {
        
        Node *L;
        L = (Node *)malloc(sizeof(Node));   //申请头结点空间
        L->next = NULL;                  //初始化一个空链表
        Node *r;
        r = L;                          //r始终指向终端结点，开始时指向头结点
        int x;                         //x为链表数据域中的数据
        while(scanf("%d",&x) != EOF) {
        
            Node *p;
            p = (Node *)malloc(sizeof(Node));   //申请新的结点
            p->data = x;                     //结点数据域赋值
            r->next = p;            //将结点插入到表头L-->|1|-->|2|-->NULL
            r = p;
        }
        r->next = NULL;
        return L;
    }

**遍历单链表如打印、修改：**  
从链表的头开始，逐步向后进行每一个元素的访问，称为遍历。  
对于遍历操作，我们可以衍生出很多常用的数据操作，比如查询元素，修改元素，获取元素个数，打印整个链表数据等等。  
进行遍历的思路极其简单，只需要建立一个指向链表L的结点，然后沿着链表L逐个向后搜索即可，代码如下：

//便利输出单链表
    void printList(LinkedList L){
        
        Node *p=L->next;
        int i=0;
        while(p){
        
            printf("第%d个元素的值为:%d\n",++i,p->data);
            p=p->next;
        }
    }

对于元素修改操作，以下是代码实现：

//链表内容的修改，在链表中修改值为x的元素变为为k。
    LinkedList LinkedListReplace(LinkedList L,int x,int k) {
        
        Node *p=L->next;
        int i=0;
        while(p){
        
            if(p->data==x){
        
                p->data=k;
            }
            p=p->next;
        }
        return L;
    }

简单的遍历设计的函数只需要void无参即可，而当涉及到元素操作时，可以设计一个LinkedList类型的函数，使其返回一个操作后的新链表。

**插入操作：**  
链表的插入操作主要分为查找到第i个位置，将该位置的next指针修改为指向我们新插入的结点，而新插入的结点next指针指向我们i+1个位置的结点。  
其操作方式可以设置一个前驱结点，利用循环找到第i个位置，再进行插入。  
如图，在DATA1和DATA2数据结点之中插入一个NEW\_DATA数据结点：  
从原来的链表状态  
![在这里插入图片描述][20201122172834921.png_pic_center]  
到新的链表状态：  
![在这里插入图片描述][20201122172908566.png_pic_center]  
代码实现如下：

//单链表的插入，在链表的第i个位置插入x的元素
      
    LinkedList LinkedListInsert(LinkedList L,int i,int x) {
        
        Node *pre;                      //pre为前驱结点
        pre = L;
        int tempi = 0;
        for (tempi = 1; tempi < i; tempi++) {
        
            pre = pre->next;                 //查找第i个位置的前驱结点
        }
        Node *p;                                //插入的结点为p
        p = (Node *)malloc(sizeof(Node));
        p->data = x;
        p->next = pre->next;
        pre->next = p;
      
        return L;
    }

**删除操作：**  
删除元素要建立一个前驱结点和一个当前结点，当找到了我们需要删除的数据时，直接使用前驱结点跳过要删除的结点指向要删除结点的后一个结点，再将原有的结点通过free函数释放掉。如图所示：  
![在这里插入图片描述][20201122173107966.png_pic_center]  
代码如下：

//单链表的删除，在链表中删除值为x的元素
      
    LinkedList LinkedListDelete(LinkedList L,int x) {
        
        Node *p,*pre;                   //pre为前驱结点，p为查找的结点。
        p = L->next;
         
        while(p->data != x) {
                      //查找值为x的元素
            pre = p;
            p = p->next;
        }
        pre->next = p->next;          //删除操作，将其前驱next指向其后继。
        free(p);
         
        return L;
    }

**2. 循环链表：**  
说完单链表，我们继续来看一下循环链表。循环链表是一种特殊的单链表，特殊之处在于，我们在单链表中，尾节点的后继指针或者引用不是指向一个具体的节点，而是指向一个空地址NULL，表示这就是最后一个节点。而将单链表的尾节点从指向空地址NULL调整为指向头结点Head，就形成了循环链表。  
![在这里插入图片描述][2020112217343637.png_pic_center]  
和单链表相比，循环链表的优点是从链尾到链头比较方便。当要处理的数据具有环型结构特点时，就特别适合采用循环链表。

**循环链表结点设计（以单循环链表为例）：**

data表示数据；  
next表示指针，它总是指向自身的下一个结点，对于只有一个结点的存在，这个next指针则永远指向自身，对于一个链表的尾部结点，next永远指向开头。  
其代码如下：

typedef struct list{
        
        int data;
        struct list *next;
    }list;
    //data为存储的数据，next指针为指向下一个结点

**循环单链表初始化：**  
先创建一个头结点并且给其开辟内存空间，在开辟内存空间成功之后，将头结点的next指向head自身，创建一个init函数来完成；  
为了重复创建和插入，我们可以在init函数重新创建的结点next指向空，而在主函数调用创建之后，将head头结点的next指针指向自身。  
这样的操作方式可以方便过后的创建单链表，直接利用多次调用的插入函数即可完成整体创建。  
其代码如下：

//初始结点
    list *initlist(){
        
        list *head=(list*)malloc(sizeof(list));
        if(head==NULL){
        
            printf("创建失败，退出程序");
            exit(0);
        }else{
        
            head->next=NULL;
            return head;
        }
    }

在主函数重调用可以是这样：

//初始化头结点//
        list *head=initlist();
        head->next=head;

**循环链表的创建操作：**  
如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 5]  
通过逐步的插入操作，创建一个新的节点，将原有链表尾结点的next指针修改指向到新的结点，新的结点的next指针再重新指向头部结点，然后逐步进行这样的插入操作，最终完成整个单项循环链表的创建。  
其代码如下：

//创建——插入数据
    int insert_list(list *head){
        
        int data;   //插入的数据类型
        printf("请输入要插入的元素：");
        scanf("%d",&data);
      
        list *node=initlist();
        node->data=data;
        //初始化一个新的结点，准备进行链接
      
        if(head!=NULL){
        
            list *p=head;
            //找到最后一个数据
            while(p->next!=head){
        
                p=p->next;
            }
            p->next=node;
            node->next=head;
            return 1;
        }else{
        
            printf("头结点已无元素\n");
            return 0;
        }
      
    }

**循环单链表的插入操作：**  
如图，对于插入数据的操作，可以创建一个独立的结点，通过将需要插入的结点的上一个结点的next指针指向该节点，再由需要插入的结点的next指针指向下一个结点的方式完成插入操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 6]  
其代码如下：

//插入元素
    list *insert_list(list *head,int pos,int data){
        
        //三个参数分别是链表，位置，参数
        list *node=initlist();  //新建结点
        list *p=head;       //p表示新的链表
        list *t;
        t=p;
        node->data=data;
        if(head!=NULL){
        
            for(int i=1;i<pos;i++){
        
                t=t->next;  //走到需要插入的位置处
            }
            node->next=t->next;
            t->next=node;
            return p;
        }
        return p;
    }

**循环单链表的删除操作：**  
如下图所示，循环单链表的删除操作是先找到需要删除的结点，将其前一个结点的next指针直接指向删除结点的下一个结点即可。  
需要注意的是尾结点，因为删除尾节点后，尾节点前一个结点就成了新的尾节点，这个新的尾节点需要指向的是头结点而不是空。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 7]  
其代码如下：

//删除元素
    int delete_list(list *head) {
        
        if(head == NULL) {
        
            printf("链表为空！\n");
            return 0;
        }
        //建立临时结点存储头结点信息（目的为了找到退出点）
        //如果不这么建立的化需要使用一个数据进行计数标记，计数达到链表长度时自动退出
        //循环链表当找到最后一个元素的时候会自动指向头元素，这是我们不想让他发生的
        list *temp = head;          
        list *ptr = head->next;
      
        int del;
        printf("请输入你要删除的元素：");
        scanf("%d",&del);
      
        while(ptr != head) {
        
            if(ptr->data == del) {
        
                if(ptr->next == head) {
         
                    temp->next = head;
                    free(ptr);
                    return 1;
                }
                temp->next = ptr->next;    //核心删除操作代码
                free(ptr);
                //printf("元素删除成功！\n");
                return 1;
            }
            temp = temp->next;
            ptr = ptr->next;
        }
        printf("没有找到要删除的元素\n");
        return 0;
    }

**循环单链表的遍历：**  
与普通的单链表和双向链表的遍历不同，循环链表需要进行结点的特殊判断。  
先找到尾节点的位置，由于尾节点的next指针是指向头结点的，所以不能使用链表本身是否为空（NULL）的方法进行简单的循环判断，我们需要通过判断结点的next指针是否等于头结点的方式进行是否完成循环的判断。  
此外还有一种计数的方法，即建立一个计数器count=0，每一次next指针指向下一个结点时计数器+1，当count数字与链表的节点数相同的时候即完成循环；  
但是这样做会有一个问题，就是获取到链表的节点数同时，也需要完成一次遍历才可以达成目标。  
其代码如下：

//遍历元素
    int display(list *head) {
        
        if(head != NULL) {
        
            list *p  = head;
            //遍历头节点到，最后一个数据
            while(p->next != head ) {
        
                printf("%d   ",p->next->data);
                p = p->next;
            }
            printf("\n");   //换行
            //把最后一个节点赋新的节点过去
            return 1;
        } else {
        
            printf("头结点为空!\n");
            return 0;
        }
    }

**3. 双向链表**：  
单向链表是单向的，只有一个后继指针或者引用Next指向后面的节点，而双向链表，指的是一个链表结构，它支持两个方向，每个节点不止只有一个后继指针或者引用Next指向后继节点，还有一个前驱指针或者引用Prev指向前面的节点  
![在这里插入图片描述][2020112217472755.png_pic_center]  
从图中可以得知，双向链表需要额外的空间来存储后继节点和前驱节点的地址，所以，存储同样多的数据，双向链表要比单向链表需要的存储空间要多。  
虽然两个指针或者引用比较浪费存储空间，但可以支持双向遍历，这样也带来了双向链表操作的灵活性。  
从双向链表的结构看，双向链表可以在O(1)的时间复杂度下找到前驱节点，基于此特性，在某些特殊的场景下，对节点的删除和插入操作，双向链表比单向链表会更高效。我们先看一下删除指定指针或引用指向的节点操作。要删除指定指针或引用指向的节点，首先我们需要遍历整个链表，找到指定的节点X；找到节点X之后，我们需要找到其前驱节点，对于单向链表来说，他是不支持直接获取前驱节点的，所以我们还需要重新再遍历一遍整个链表，找到节点X的前驱节点才能执行删除操作；  
对于双向链表来说，这种情况就比较有优势了，找到指定节点X之后，它并不需要重新再遍历一遍链表寻找前驱节点，因为双向链表中的结点已经保存了前驱结点的指针或者引用；

**双向链表的结点设计：**  
对于每一个结点而言，有：  
![在这里插入图片描述][20201122175257488.png_pic_center]  
其中，DATA表示数据，其可以是简单的类型也可以是复杂的结构体；  
pre代表的是前驱指针，它总是指向当前结点的前一个结点，如果当前结点是头结点，则pre指针为空；  
next代表的是后继指针，它总是指向当前结点的下一个结点，如果当前结点是尾结点，则next指针为空  
其代码设计如下：

typedef struct line{
        
        int data;           //data
        struct line *pre;   //pre node
        struct line *next;  //next node
    }line,*a;
    //分别表示该结点的前驱(pre)，后继(next)，以及当前数据(data)

**双链表的创建：**  
创建双向链表需要先创建头结点，然后逐步的进行添加双向链表的头结点是有数据元素的，也就是头结点的data域中是存有数据的，这与一般的单链表是不同的。  
对于逐步添加数据，先开辟一段新的内存空间作为新的结点，为这个结点进行的data进行赋值，然后将已成链表的上一个结点的next指针指向自身，自身的pre指针指向上一个结点。  
其代码可以设计为：

//创建双链表
    line* initLine(line * head){
        
        int number,pos=1,input_data;
        //三个变量分别代表结点数量，当前位置，输入的数据
        printf("请输入创建结点的大小\n");
        scanf("%d",&number);
        if(number<1){
        return NULL;} //输入非法直接结束
        //头结点创建///
        head=(line*)malloc(sizeof(line));
        head->pre=NULL;
        head->next=NULL;
        printf("输入第%d个数据\n",pos++);
        scanf("%d",&input_data);
        head->data=input_data;
      
        line * list=head;
        while (pos<=number) {
        
            line * body=(line*)malloc(sizeof(line));
            body->pre=NULL;
            body->next=NULL;
            printf("输入第%d个数据\n",pos++);
            scanf("%d",&input_data);
            body->data=input_data;
            
            list->next=body;
            body->pre=list;
            list=list->next;
        }
        return head;
    }

双向链表创建的过程可以分为：创建头结点->创建一个新的结点->将头结点和新结点相互链接->再度创建新结点，这样会有助于理解。

**双向链表的插入操作：**  
如图所示：  
![在这里插入图片描述][20201122175529493.png_pic_center]  
对于每一次的双向链表的插入操作，首先需要创建一个独立的结点，并通过malloc操作开辟相应的空间；  
其次我们选中这个新创建的独立节点，将其的pre指针指向所需插入位置的前一个结点；  
同时，其所需插入的前一个结点的next指针修改指向为该新的结点，该新的结点的next指针将会指向一个原本的下一个结点，而修改下一个结点的pre指针为指向新结点自身，这样的一个操作我们称之为双向链表的插入操作。  
其代码可以表示为：

//插入数据
    line * insertLine(line * head,int data,int add){
        
        //三个参数分别为：进行此操作的双链表，插入的数据，插入的位置
        //新建数据域为data的结点
        line * temp=(line*)malloc(sizeof(line));
        temp->data=data;
        temp->pre=NULL;
        temp->next=NULL;
        //插入到链表头，要特殊考虑
        if (add==1) {
        
            temp->next=head;
            head->pre=temp;
            head=temp;
        }else{
        
            line * body=head;
            //找到要插入位置的前一个结点
            for (int i=1; i<add-1; i++) {
        
                body=body->next;
            }
            //判断条件为真，说明插入位置为链表尾
            if (body->next==NULL) {
        
                body->next=temp;
                temp->pre=body;
            }else{
        
                body->next->pre=temp;
                temp->next=body->next;
                body->next=temp;
                temp->pre=body;
            }
        }
        return head;
    }

**双向链表的删除操作：**  
如图：  
![在这里插入图片描述][2020112217565716.png_pic_center]  
删除操作的过程是：选择需要删除的结点->选中这个结点的前一个结点->将前一个结点的next指针指向自己的下一个结点->选中该节点的下一个结点->将下一个结点的pre指针修改指向为自己的上一个结点。  
在进行遍历的时候直接将这一个结点给跳过了，之后，我们释放删除结点，归还空间给内存，这样的操作我们称之为双链表的删除操作。  
其代码可以表示为：

//删除元素
    line * deleteLine(line * head,int data){
        
        //输入的参数分别为进行此操作的双链表，需要删除的数据
        line * list=head;
        //遍历链表
        while (list) {
        
            //判断是否与此元素相等
            //删除该点方法为将该结点前一结点的next指向该节点后一结点
            //同时将该结点的后一结点的pre指向该节点的前一结点
            if (list->data==data) {
        
                list->pre->next=list->next;
                list->next->pre=list->pre;
                free(list);
                printf("--删除成功--\n");
                return head;
            }
            list=list->next;
        }
        printf("Error:没有找到该元素，没有产生删除\n");
        return head;
    }

**双向链表的遍历：**  
双向链表的遍历利用next指针逐步向后进行索引即可。  
注意，在判断这里，我们既可以用while(list)的操作直接判断是否链表为空，也可以使用while(list->next)的操作判断该链表是否为空，其下一节点为空和本结点是否为空的判断条件是一样的效果。  
其简单的代码可以表示为：

//遍历双链表,同时打印元素数据
    void printLine(line *head){
        
        line *list = head;
        int pos=1;
        while(list){
        
            printf("第%d个数据是:%d\n",pos++,list->data);
            list=list->next;
        }
    }

**4. 双向循环链表：**  
上面我们说了单向链表、循环链表、双向链表，我们将循环链表和双向链表整合在一起，就形成了双向循环链表。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 8]  
不过，数组和链表的对比，并不能局限于时间复杂度。而且，在实际的软件开发中，不能仅仅利用复杂度分析就决定使用哪个数据结构来存储数据，一切都要根据具体情况具体分析，合适最好

**关于链表的总结：**

在顺序表中做插入删除操作时，平均移动大约表中一半的元素，因此对n较大的顺序表效率低。并且需要预先分配足够大的存储空间，而链表恰恰是其中运用的精华。

基于存储，运算，环境这几方面考虑，可以让我们更好的在项目中使用链表

此外，有关链表的排序问题，也需要我们格外关注哟！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/6ea88de4f0c64bc287f4c6fb6f43874f.png
[20201122165209818.png_pic_center]: /images/20221120/fbfc045db5bb4436aba8bfbdc7f29818.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/17ad8a2a40cc4aaa994faf9e48f3f23b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/12412a48fff64299ae66a87ea51ed9de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/58302dfe56264be08ada1c71d84dbc84.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/13feb8aea98e499db1ad34ba579b8451.png
[20201122172834921.png_pic_center]: /images/20221120/54169ec545ad42d19a1fcc6256359945.png
[20201122172908566.png_pic_center]: /images/20221120/d8ff80e8343e44a0a2efea9e50a3bc9e.png
[20201122173107966.png_pic_center]: /images/20221120/8a63b7b30139486baadc037bf2450d44.png
[2020112217343637.png_pic_center]: https://img-blog.csdnimg.cn/2020112217343637.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201122173937630.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201122174125961.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201122174255608.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70#pic_center
[2020112217472755.png_pic_center]: https://img-blog.csdnimg.cn/2020112217472755.png#pic_center
[20201122175257488.png_pic_center]: https://img-blog.csdnimg.cn/20201122175257488.png#pic_center
[20201122175529493.png_pic_center]: https://img-blog.csdnimg.cn/20201122175529493.png#pic_center
[2020112217565716.png_pic_center]: https://img-blog.csdnimg.cn/2020112217565716.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201122180017315.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70#pic_center