链表-链表的基本操作（C语言代码实现）

已于 2024-08-29 09:37:25 修改
阅读量1k 收藏 19
点赞数 20
分类专栏： C++知识分享 文章标签： 链表 c语言 数据结构
于 2024-08-29 09:36:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45398836/article/details/141531417
版权

概述

本篇文章将向您介绍循环单/双链表的插入、删除、遍历操作原理及如何进行，文章最后会给正在学习链表操作的小伙伴提供两道力扣经典习题，后附参考代码。

1.循环单链表的插入操作

如图，对于插入数据的操作，基本与单链表的插入操作相同，我们可以创建一个独立的结点，通过将需要插入的结点的上一个结点的next指针指向该节点，再由需要插入的结点的next指针指向下一个结点的方式完成插入操作。

其代码可以表示为：

//插入元素
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;
}

2. 循环单链表的删除操作

如图所示，循环单链表的删除操作可以参考单链表的删除操作，其都是找到需要删除的结点，将其前一个结点的next指针直接指向删除结点的下一个结点即可，但需要注意的是尾节点和头结点的特判，尤其是尾结点，因为删除尾节点后，尾节点前一个结点就成了新的尾节点，这个新的尾节点需要指向的是头结点而不是空，其重点可以记录为【当前的前一节点.next=自身结点.next】这样的操作可以省去头尾结点的特判：

其代码可以表示为：

//删除元素
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;
}

3. 循环单链表的遍历

与普通的单链表和双向链表的遍历不同，循环链表需要进行结点的特判，找到尾节点的位置，由于尾节点的next指针是指向头结点的，所以不能使用链表本身是否为空（NULL）的方法进行简单的循环判断，我们需要通过判断结点的next指针是否等于头结点的方式进行是否完成循环的判断。

此外还有一种计数的方法，即建立一个计数器count=0，每一次next指针指向下一个结点时计数器加一，当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");   //习惯性换行 ( o=^•ェ•)o　┏━┓
        //把最后一个节点赋新的节点过去
        return 1;
    } else {
        printf("头结点为空!\\n");
        return 0;
    }
}

4. 进阶概念—双向循环链表

循环链表还有一个进阶的概念练习，同双向链表与单链表的关系一样，循环单链表也有一个孪生兄弟——双向循环链表，其设计思路与单链表和双向链表的设计思路一样，就是在原有的双向链表的基础上，将尾部结点和头部结点进行互相连接，这个链表的设计不难，就交给读者自主进行设计。

5. 循环单链表代码

#include<stdio.h>
#include<stdlib.h>
typedef struct list{
    int data;
    struct list *next;
}list;
//data为存储的数据，next指针为指向下一个结点
 
//初始结点
list *initlist(){
    list *head=(list*)malloc(sizeof(list));
    if(head==NULL){
        printf("创建失败，退出程序");
        exit(0);
    }else{
        head->next=NULL;
        return head;
    }
}
 
//创建--插入数据
int create_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;
    }
 
}
 
//插入元素
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;
}
 
//删除元素
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) { //循环结束的条件换成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;
}
 
 
//遍历元素
int display(list *head) {
    if(head != NULL) {
        list *p  = head;
        //遍历头节点到，最后一个数据
        while(p->next != head ) {
            printf("%d   ",p->next->data);
            p = p->next;
        }
        printf("\\n");   //习惯性换行 ( o=^•ェ•)o　┏━┓
        //把最后一个节点赋新的节点过去
        return 1;
    } else {
        printf("头结点为空!\\n");
        return 0;
    }
}
 
int main(){
    //初始化头结点//
    list *head=initlist();
    head->next=head;
    通过插入元素完善链表/
    for(int i=0;i<5;i++){   //只是演示使用，不具体提供输入
        create_list(head);
    }
    display(head);
    插入元素
    head=insert_list(head,1,10);
    display(head);
    删除元素
    delete_list(head);
    display(head);
    return 0;
}

 6. 双向链表的插入操作

如图所示：

对于每一次的双向链表的插入操作，我们首先需要创建一个独立的结点并通过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;
}

7. 双向链表的删除操作

如图：

删除操作的过程是：选择需要删除的结点，选中这个结点的前一个结点，将前一个结点的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;
}

8. 双向链表的遍历

如同单链表的遍历一样，利用next指针逐步向后进行索引即可，注意判断这里，我们既可以用while(list)的操作直接判断是否链表为空，也可以使用while(list->next)的操作判断该链表是否为空，其下一节点为空和本结点是否为空的判断条件是一样的效果，当然了，善用双向链表的pre指针进行有效的遍历也是值得去尝试的。

其简单的代码可以表示为：

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

9. 配套练习题目

双向链表的单独训练数据并不是很多，在网上的资料相比单链表也是偏少，不过我们在熟悉原理之后可以同单链表的题目，可以尝试使用双链表进行做题，如下题：

1676题    1585题

10. 本题目案例代码

#include<stdio.h>
#include<stdlib.h>
typedef struct line{
    int data;           //data
    struct line *pre;   //pre node
    struct line *next;  //next node
}line;
//分别表示该结点的前驱(pre)，后继(next)，以及当前数据(data)
 
//遍历双链表,同时打印元素数据
void printLine(line *head){
    line *list = head;
    int pos=1;
    while(list){
        printf("第%d个数据是:%d\\n",pos++,list->data);
        list=list->next;
    }
}
 
//创建双链表
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;
}
 
//插入数据
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;
}
 
//删除元素
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;
}
 
int main(){
    line *head=NULL;
    printf("创建双链表操作\\n"); 
    head=initLine(head);
    printLine(head);
//create line
    printf("插入操作\\n"); 
    head=insertLine(head,40,2);     //为了简化直接写参数了
    printLine(head);
//insert Line
    printf("删除操作\\n"); 
    head=deleteLine(head,2);       //为了简化直接写参数了
    printLine(head);
//delete Line  
    return 0;
}

Dola_Pan
关注
专栏目录
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
C语言实现链表基本操作
qq_56066173的博客
08-20 4809
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
双向链表的基本操作及C语言代码实现
weixin_51884452的博客
03-28 404
双向链表的基本操作及c语言代码实现
链表的基本操作--c语言
qq_51533157的博客
06-25 6035
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
链表基本操作源码
12-28
c 语言 链表基本操作，创建 查找 删除 插入 双向链表源码
C语言链表操作
10-10
C语言链表操作，新手强烈推荐必看内容，不看会后悔。。。
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
链表-使用C语言实现循环链表.zip
03-13
本资源“链表-使用C语言实现循环链表.zip”将详细介绍如何用C语言来创建和操作循环链表。 首先，我们要理解循环链表的基本概念。循环链表是一种链表，其最后一个节点的指针不是NULL，而是指向链表的第一个节点，...
链表-基于C语言实现的循环链表.zip
最新发布
06-28
链表 链表_基于C语言实现的循环链表
链表基本操作
07-02
实现线性表的查找、删除、计数、输出、排序、逆置等运算，插入、删除、查找、计数、输出、排序、逆置要单独写成函数，并能在屏幕上输出操作前后的结果。
链表的操作（C语言）
weixin_52545652的博客
07-07 480
链表
C语言链表简单操作
qq_45768871的博客
02-01 766
文章目录C语言链表简单操作创建链表 初始化链表头插法尾插法任意位置插法删除链表中的指定数字返回链表中第i个结点（地址）根据数值查找返回节点的位置删除链表中第i个结点，并且用x带出删除的值链表中查找是否结点的数据等于x，如果存在，返回该结点的指针，否则返回NULL获取链表长度销毁链表，释放内存总代码 C语言链表简单操作 创建链表 初始化链表 //创建链表 LinkList createList() { // 头部空节点 LinkList L = (LinkList)malloc(sizeof(L
链表各类操作详解
weixin_33719619的博客
06-17 351
仅供学习使用，附转载连接：http://blog.csdn.net/hackbuteer1/article/details/6591486链表概述　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分...
链表基本操作（完整代码）
Czc1357618897的博客
12-02 1020
链表基本操作（完整代码） 首先汇总一下单链表的基本操作（带头结点）： 1.单链表的创建 （1）头插法创建链表 （2）尾插法创建链表 2.单链表的打印 3.单链表的查询 4.结点插入 （1）头部插入 （2）任意位置插入 （3）尾部插入 5.结点删除 更加详细请看链表基本操作（详解）. 完整代码： #include<stdio.h> #include<string.h> #include<stdlib.h> struct student { int numb
C语言链表操作详解
热门推荐
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
C语言数据结构-链表的基本操作（超详细）
2301_79975618的博客
01-17 5897
目录：1.单链表的分类；2.单链表的操作；3.代码详解；4.完整代码展示；一：单链表的分类总体上来说，单链表可以分为两大类，一种是带头结点的，另一种是不带头结点的（如果分细来讲，链表的插入可以分为两种：头插法和尾插法。二：单链表的操作1.单链表的初始化；2.单链表的头插法；3.单链表的尾插法；4.删除元素；5.遍历链表；
【数据结构】C语言实现链表操作
Stafen_的博客
02-18 3771
链表：线性表的链式存储结构详细操作教程
c语言链表的基本操作
07-27
c语言链表的基本操作包括创建链表、插入元素、删除元素、读取链表和销毁链表。在给出具体操作之前，我先解释一下引用内容中的代码。 引用\[1\]中的代码是作者在学习数据结构时遇到的问题和解决方法。作者通过重新学习C语言和指针相关的知识，成功地理解了指针的概念，并能够使用C语言实现数据结构中的算法。 引用\[2\]中的代码是作者在解决链表内存访问冲突问题时采用的二级指针的方法。作者通过使用二级指针，解决了链表创建后内存访问冲突的问题。 引用\[3\]中的代码是一个主函数，用于测试链表的基本操作功能。其中包括创建链表、读取链表、插入元素、删除元素和销毁链表等操作。 现在我来回答你的问题，c语言链表的基本操作如下： 1. 创建链表：创建一个头结点为head的链表。可以通过申请内存空间来创建链表，并将头结点的指针赋值给head。 2. 插入元素：在链表中指定的结点前插入元素e。可以通过遍历链表找到指定的结点，然后创建一个新的结点，并将新结点的指针指向指定结点的下一个结点，再将指定结点的指针指向新结点。 3. 删除元素：删除链表中指定的结点。可以通过遍历链表找到指定的结点，然后将指定结点的前一个结点的指针指向指定结点的下一个结点，再释放指定结点的内存空间。 4. 读取链表：读取链表的数据域并打印。可以通过遍历链表，依次读取每个结点的数据域，并将其打印出来。 5. 销毁链表：释放为链表申请的内存空间。可以通过遍历链表，依次释放每个结点的内存空间。 以上就是c语言链表的基本操作。希望对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [C语言实现链表的基本操作（超详细注释）](https://blog.csdn.net/weixin_63069485/article/details/123784826)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dola_Pan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值