C语言基础教程_链表

最新推荐文章于 2022-10-19 19:58:10 发布
最新推荐文章于 2022-10-19 19:58:10 发布
阅读量546 收藏 10
点赞数 6
分类专栏： C语言基础教程 文章标签： 链表 c语言 数据结构 青少年编程 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59519697/article/details/124550125
版权

文章目录

前言

博客主页：博客主页
欢迎大家点赞收藏关注留言，如有错误，敬请指正

共同学习，一起进步。

一、链表的概念

1.1定义

链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

1.2特点

链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成（malloc），每个节点包括两个部分：
一个是存储数据元素的数据域
另一个是存储下一个节点地址的指针域

在这里插入图片描述

1.3链表的构成

链表由一个个节点构成，每个节点一般采用结构体的形式组织，例如：

typedef struct student｛
	int num；
	char name[20]；
	struct student *next；
}STU;

链表节点分为两个域
数据域：存放各种实际的数据，如：num、score等
指针域：存放下一节点的首地址，如：next等
在这里插入图片描述

1.4链表的操作

创建 增 删 改 查

二、链表的创建

第一步：创建一个结点
第二步：创建第二个结点，并放在第一个结点的后面（第一个结点指针域保存第二个结点地址）
第三步：再次创建结点，找到原本链表中最后一个结点，接着将最后一个结点的指针域保存新节点的地址，以此类推。
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }
}

三、链表的遍历

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);
}

执行结果：
在这里插入图片描述

四、链表的释放

重新定义一个指针q保存p指向结点的地址，然后p后移保存下一个结点的地址，然后释放q对应节点，以此类推，知道p位NULL
在这里插入图片描述

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

五、链表结点的查找

先对比第一个结点的数据域是否是想要的数据，如果是直接返回，如果不是则继续查找下一个结点，如果达到最后一个结点都没有匹配的数据，则说明查找的数据不存在

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表的查找
//按照学号查找
STU * link_search_num(STU *head,int num)
{
    STU *p_mov;
    //定义的指针变量保存第一个结点的地址
    p_mov=head;
    //当没有到达最后一个结点的指针域时循环继续
    while(p_mov!=NULL)
    {
        //如果找到是当前结点的数据，则返回当前结点的地址
        if(p_mov->num == num)//找到了
        {
            return p_mov;
        }
        //如果没有找到，则继续对比下一个结点的指针域
        p_mov=p_mov->next;
    }

    //当循环结束的时候还没有找到，说明要查找的数据不存在，返回NULL进行标识
    return NULL;//没有找到
}

//按照姓名查找
STU * link_search_name(STU *head,char *name)
{
    STU *p_mov;
    p_mov=head;
    while(p_mov!=NULL)
    {
        if(strcmp(p_mov->name,name)==0)//找到了
        {
            return p_mov;
        }
        p_mov=p_mov->next;
    }
    return NULL;//没有找到
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);

    //查学号
#if 1
    STU *pb;
    while(1)
    {
        printf("请输入您要查找学生的学号\n");
        scanf("%d",&num);
        pb=link_search_num(head,num);
        if(pb!=NULL)//找到了
        {
            printf("找到了 num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        }
        else
        {
            printf("没有找到您要查找的节点\n");
        }
    }
#endif

    //查姓名
#if 0
    char name[32] = "";
    while(1)
    {
        printf("请输入您要查找学生的姓名\n");
        scanf("%s",name);
        pb=link_search_name(head,name);
        if(pb!=NULL)//找到了
        {
            printf("找到了 num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        }
        else
        {
            printf("没有找到您要查找的节点\n");
        }
    }
#endif
    link_free(&head);
}

执行结果：
在这里插入图片描述

六、链表结点的删除

如果链表位空，不需要删除
如果要删除的是第一个结点，则需要保存链表首地址的指针保存第一个结点的下一个结点的地址
如果删除的是中间结点，则找到中间结点的前一个结点，让前一个结点的指针域保存这个结点的后一个结点的地址

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表结点的删除
void link_delete_num(STU **p_head,int num)
{
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head == NULL)//链表为空，不用删
    {
        printf("链表为空，没有您要删的节点");\
        return ;
    }
    while(pb->num != num && pb->next !=NULL)//循环找，要删除的节点
    {
        pf=pb;
        pb=pb->next;
    }
    if(pb->num == num)//找到了一个节点的num和num相同
    {
        if(pb == *p_head)//要删除的节点是头节点
        {
            //让保存头结点的指针保存后一个结点的地址
            *p_head = pb->next;
        }
        else
        {
            //前一个结点的指针域保存要删除的后一个结点的地址
            pf->next = pb->next;
        }

        //释放空间
        free(pb);
        pb = NULL;
    }
    else//没有找到
    {
        printf("没有您要删除的节点\n");
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);

    printf("请输入您要删除的节点的学号\n");
    scanf("%d",&num);
    link_delete_num(&head,num);

    link_print(head);

    link_free(&head);
}

执行结果：
在这里插入图片描述

七、链表中插入一个结点

链表中插入一个结点，按照原本链表的顺序插入，找到合适的位置
在这里插入图片描述
情况（按照从小到大）：
如果链表没有结点，则新插入的就是第一个结点
如果新插入的结点的数值最小，则作为头结点
如果新插入的数值在中间位置，则找到前一个，然后插入到他们中间
如果新插入的结点的数值最大，则插入到最后

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表的插入：按照学号的顺序插入
void link_insert_num(STU **p_head,STU *p_new)
{
    STU *pb,*pf;
    pb=pf=*p_head;
    if(*p_head ==NULL)// 链表为空链表
    {
        *p_head = p_new;
        p_new->next=NULL;
        return ;
    }
    while((p_new->num >= pb->num)  && (pb->next !=NULL) )
    {
        pf=pb;
        pb=pb->next;
    }

    if(p_new->num < pb->num)//找到一个节点的num比新来的节点num大，插在pb的前面
    {
        if(pb== *p_head)//找到的节点是头节点，插在最前面
        {
            p_new->next= *p_head;
            *p_head =p_new;
        }
        else
        {
            pf->next=p_new;
            p_new->next = pb;
        }
    }
    else//没有找到pb的num比p_new->num大的节点，插在最后
    {
        pb->next =p_new;
        p_new->next =NULL;
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);

    while(1)
    {
        printf("请输入您要插入的节点的 num score name\n");
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        link_insert_num(&head,p_new);
        link_print(head);
    }

    link_free(&head);
}

执行结果：
在这里插入图片描述

八、链表排序

如果链表为空，不需要排序
如果链表中只有一个结点，不需要排序
先将第一个结点与后面的所有结点一次对比数据域，只要比第一个结点的数据域小的，则交换位置，
交换之后，那新的第一个结点的数据域再与下一个结点再次比较，如果比他小，再次交换，以此类推
第一个结点确定，接下来再与第二个结点（后面所有的结点）对比，知道最后一个结点也确定

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表的排序
void link_order(STU *head)
{
    STU *pb,*pf,temp;
    pf=head;

    if(head==NULL)
    {
        printf("链表为空,不用排序\n");
        return ;
    }

    if(head->next ==NULL)
    {
        printf("只有一个节点，不用排序\n");
        return ;
    }

    while(pf->next !=NULL)//以pf指向的节点为基准节点，
    {
        pb=pf->next;//pb从基准元素的下个元素开始
        while(pb!=NULL)
        {
            if(pf->num > pb->num)
            {
                temp=*pb;
                *pb=*pf;
                *pf=temp;

                temp.next=pb->next;
                pb->next=pf->next;
                pf->next=temp.next;
            }
            pb=pb->next;
        }
        pf=pf->next;
    }
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);

    printf("***************************\n");

    link_order(head);

    link_print(head);

    link_free(&head);
}

执行结果：
在这里插入图片描述

九、链表的逆序

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名
    //指针域
    struct student *next;
}STU;

void link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov = *p_head;
    if(*p_head == NULL)	//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->next=NULL;
    }
    else //第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }

        p_mov->next = p_new;	//将新申请的节点加入链表
        p_new->next = NULL;
    }
}

//链表的遍历
void link_print(STU *head)
{
    STU *p_mov;
    //定义新的指针保存链表的首地址，防止使用head改变原本链表
    p_mov = head;
    //当指针保存最后一个结点的指针域为NULL时，循环结束
    while(p_mov!=NULL)
    {
        //先打印当前指针保存结点的指针域
        printf("num=%d score=%d name:%s\n",p_mov->num,\
               p_mov->score,p_mov->name);

        //指针后移，保存下一个结点的地址
        p_mov = p_mov->next;
    }
}

//链表的释放
void link_free(STU **p_head)
{
    //定义一个指针变量保存头结点的地址
    STU *pb=*p_head;

    while(*p_head!=NULL)
    {
        //先保存p_head指向的结点的地址
        pb=*p_head;
        //p_head保存下一个结点地址
        *p_head=(*p_head)->next;
        //释放结点并防止野指针
        free(pb);
        pb = NULL;
    }
}

//链表逆序
STU *link_reverse(STU *head)
{
    STU *pf,*pb,*r;
    pf=head;
    pb=pf->next;

    while(pb!=NULL)
    {
        r=pb->next;
        pb->next=pf;
        pf=pb;
        pb=r;
    }
    head->next=NULL;
    head=pf;
    return head;
}

int main()
{
    STU *head = NULL,*p_new = NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        p_new = (STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n"); //给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);

        link_creat_head(&head,p_new);	//将新节点加入链表
    }

    link_print(head);

    printf("***********************\n");

    head = link_reverse(head);

    link_print(head);

    link_free(&head);
}

执行结果：
在这里插入图片描述

十、双向链表

在这里插入图片描述

10.1双向链表的创建和遍历

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名

    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov=*p_head;
    if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->front = NULL;
        p_new->next = NULL;
    }
    else	//第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;
    }
}


void double_link_print(STU *head)
{
    STU *pb;
    pb=head;
    while(pb->next!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);

    printf("***********************\n");

    while(pb!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

int main()
{
    STU *head=NULL,*p_new=NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n");	//给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_creat_head(&head,p_new);	//将新节点加入链表
    }

    double_link_print(head);
}

执行结果：

在这里插入图片描述

10.2双向链表结点的删除

如果链表为空，则不需要删除
如果删除第一个结点，则保存链表首地址的指针保存后一个结点的地址，并且让这个结点的front保存NULL
如果删除最后一个结点，只需要让最后一个结点的前一个结点的next保存NULL即可
如果删除中间结点，则让中间结点的前后两个结点的指针域分别保存对方的地址即可

#include <stdio.h>
#include <stdlib.h>

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名

    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov=*p_head;
    if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->front = NULL;
        p_new->next = NULL;
    }
    else	//第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;
    }
}


void double_link_print(STU *head)
{
    STU *pb;
    pb=head;
    while(pb->next!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);

    printf("***********************\n");

    while(pb!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

//双向链表的删除
void double_link_delete_num(STU **p_head,int num)
{
    STU *pb,*pf;
    pb=*p_head;
    if(*p_head==NULL)//链表为空，不需要删除
    {
        printf("链表为空，没有您要删除的节点\n");
        return ;
    }
    while((pb->num != num) && (pb->next != NULL) )
    {
        pb=pb->next;
    }
    if(pb->num == num)//找到了一个节点的num和num相同，删除pb指向的节点
    {
        if(pb == *p_head)//找到的节点是头节点
        {
            if((*p_head)->next==NULL)//只有一个节点的情况
            {
                *p_head=pb->next;
            }
            else//有多个节点的情况
            {
                *p_head = pb->next;//main函数中的head指向下个节点
                (*p_head)->front=NULL;
            }
        }
        else//要删的节点是其他节点
        {
            if(pb->next!=NULL)//删除中间节点
            {
                pf=pb->front;//让pf指向找到的节点的前一个节点
                pf->next=pb->next; //前一个结点的next保存后一个结点的地址
                (pb->next)->front=pf; //后一个结点的front保存前一个结点的地址
            }
            else//删除尾节点
            {
                pf=pb->front;
                pf->next=NULL;
            }
        }

        free(pb);//释放找到的节点

    }
    else//没找到
    {
        printf("没有您要删除的节点\n");
    }
}

int main()
{
    STU *head=NULL,*p_new=NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n");	//给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_creat_head(&head,p_new);	//将新节点加入链表
    }

    double_link_print(head);

    printf("请输入您要删除的节点的num\n");
    scanf("%d",&num);
    double_link_delete_num(&head,num);
    double_link_print(head);

}

执行结果：
在这里插入图片描述

10.3双向链表插入结点

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>

//定义结点结构体
typedef struct student
{
    //数据域
    int num;		//学号
    int score;      //分数
    char name[20];  //姓名

    //指针域
    struct student *front;  //保存上一个结点的地址
    struct student *next;   //保存下一个结点的地址
}STU;

void double_link_creat_head(STU **p_head,STU *p_new)
{
    STU *p_mov=*p_head;
    if(*p_head==NULL)				//当第一次加入链表为空时，head执行p_new
    {
        *p_head = p_new;
        p_new->front = NULL;
        p_new->next = NULL;
    }
    else	//第二次及以后加入链表
    {
        while(p_mov->next!=NULL)
        {
            p_mov=p_mov->next;	//找到原有链表的最后一个节点
        }
        p_mov->next = p_new;		//将新申请的节点加入链表
        p_new->front = p_mov;
        p_new->next = NULL;
    }
}


void double_link_print(STU *head)
{
    STU *pb;
    pb=head;
    while(pb->next!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->next;
    }
    printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);

    printf("***********************\n");

    while(pb!=NULL)
    {
        printf("num=%d score=%d name:%s\n",pb->num,pb->score,pb->name);
        pb=pb->front;
    }
}

//双向链表的插入
void double_link_insert_num(STU **p_head,STU *p_new)
{
    STU *pb,*pf;
    pb=*p_head;
    if(*p_head == NULL)//链表为空，新来的节点就是头节点
    {
        *p_head=p_new;
        p_new->front=NULL;
        p_new->next=NULL;
        return ;
    }
    while((p_new->num >= pb->num) && (pb->next!=NULL) )
    {
        pb=pb->next ;
    }
    if(p_new->num < pb->num)//找到了一个pb的num比新来的节点的num大，插在pb前边
    {
        if(pb==*p_head)//找到的节点是头节点，插在头节点的前边
        {
            p_new->next=*p_head; //新插入的结点的next保存之前头结点的地址
            (*p_head)->front=p_new; //之前头结点的front保存新插入的结点的地址
            p_new->front=NULL; //新插入的结点的front保存NULL
            *p_head=p_new; //让原本保存链表首地址的指针保存新插入结点的地址
        }
        else
        {
            pf=pb->front;//pf指向 找到节点的前一个节点

            p_new->next=pb;
            p_new->front=pf;
            pf->next=p_new;
            pb->front=p_new;
        }
    }
    else//所有pb指向节点的num都比p_new指向的节点的num小，插在最后
    {
        pb->next=p_new;
        p_new->front=pb;
        p_new->next=NULL;
    }
}

int main()
{
    STU *head=NULL,*p_new=NULL;
    int num,i;
    printf("请输入链表初始个数:\n");
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入学号、分数、名字:\n");	//给新节点赋值
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_creat_head(&head,p_new);	//将新节点加入链表
    }

    double_link_print(head);

    printf("************************\n");

    while(1)
    {
        p_new=(STU*)malloc(sizeof(STU));//申请一个新节点
        printf("请输入您要插入的节点的num score name\n");
        scanf("%d %d %s",&p_new->num,&p_new->score,p_new->name);
        double_link_insert_num(&head,p_new);
        double_link_print(head);

    }
}

执行结果：
在这里插入图片描述

总结

本篇主要记录链表的基础知识。
博客主页博客主页
欢迎大家点赞收藏关注留言。
如有错误，敬请指正。

注：本篇来自千峰教育公开课程，学习笔记。

_Fang.
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
用C语言实现单链表操作
xuzhougeng blog
02-02 6581
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
链表的基本操作--c语言
qq_51533157的博客
06-25 5928
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
C语言实现链表基本操作
qq_56066173的博客
08-20 4413
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
C语言链表详解
qq_28576837的博客
06-02 4808
C语言链表详解
C语言链表_Vc_
10-01
C链表教程 PDF，讲述了链表的构造，链表的建立，内存释放，链表存储分配等相关内容，相对基础的链表教程，C爱好者的必看书籍。
八十多条C语言基础教程
07-10
里面都是我新手时期学C的时候整理的一些TXT文档，因为分不够了，所以放上来赚点积分，都是很基础的东西，里面的代码都是经过我测试的，保证可用。 (1)输出Hello,world (2)标识符 (3)常量与变量 (4)整型数据 (5)实型...
C语言链表结构体与链表免费版免费下载
03-10
总结起来，C语言中的链表通过结构体和指针实现，理解和掌握结构体的定义、引用、初始化，以及指针在链表操作中的应用，是学习C语言数据结构和算法的基础。通过熟练运用这些知识点，可以构建复杂的数据结构，实现高效...
C语言链表教程
01-17
比较不错的PPT哦，比较详细的介绍了C语言链表一些基础知识。
C语言入门教程合集-基础知识
12-13
1. **C语言基础知识**： - C语言的特点包括结构紧凑、高效执行、丰富的控制语句和运算符、灵活的数据结构以及直接硬件访问能力。 - C语言有9种控制语句，包括条件判断（if、switch）、循环（while、for、do......
c语言的双链表，菜鸟必学
10-12
重点代码：Insert->prior = p ->prior; p ->prior->next = Insert; Insert->next = p; p->prior = Insert;
【C语言】链表及单链表基本操作
swag_wg的博客
04-29 12万+
1、什么是链表？链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 数据结构中： 2、链表的分类 共有8种链表结构 ...
C语言链表操作详解
热门推荐
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
单链表的基本操作c语言实现
gongdileidechouzhu的博客
02-25 1万+
#include<stdio.h> #define false 0 #define ok 1//定义节点的结构 typedef struct node{ int data; struct node *next; }node; typedef struct node *linklist;//初始化链表，创建一个链表并赋值 void creatlist(linklist *l,int n
C语言—通用链表
别呀的博客
03-28 1621
思考：当一个项目里要使用多种结构体类型的链表，例如点菜系统里有人员、菜谱两种结构体，若要对这两种链表操作，就需要编写2套链表操作代码，对链表的操作有链表创建、添加节点、删除节点、获取链表节点个数、获取链表结点数据、释放链表等，这就会花费我们大量的时间。对于这2种业务，对链表的操作是相同的，那能不能编写一套通用的链表操作函数，这2种应用只要调用相应的操作函数即可？面临这样的问题，所以有了通用链表。 这里写目录标题通用链表设计通用链表基本操作通用链表示例 通用链表设计 通用链表结构体： struct lis.
c语言链表萌新,菜鸟的进击——玩转C语言链表
weixin_26834281的博客
05-21 1098
链表是我们学习C语言避不开的问题，就让我们一起飞过去看看吧：1 定义链表链表是C语言编程中常用的数据结构，比如我们要建一个整数链表，一般可能这么定义：struct int_node {int val;struct int_node *next;};2 定义功能函数为了实现链表的插入、删除、遍历等功能，另外要再实现一系列函数，比如：void insert_node(struct int_node *...
C语言操作链表详解
Violet277的博客
10-28 2360
C语言操作链表详解链表的概念链表的操作将数据抽象成结构体创建和初始化链表输出链表中存储的数据查找链表中指定位置中存储的数据在链表中插入数据删除指定位置的数据修改制定位置的数据逆序输出链表存储的数据执行结果 在我们学习C语言的前期，每当我们要进行大量数据的读写时，我们都会使用顺序表，也就数组，它的优点很明显，增删读写操作很简单，易于上手。但当我们对数据的存储理解更加深刻时，我们便会逐渐意识到顺序表也不是万能的，它也有它的缺点：顺序表在内存中的存储时，占用一大块连续的空间，但我们实际在使用时，可能并没有那么大的
C语言链表基本操作
qq_43745403的博客
11-09 160
#include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node *next; }LNode,*LinkList; //头插法 LinkList Creat_LinkList(){ LinkList H; LNode *p; H=(LinkList)malloc(si...
C语言数据结构之链表
qq_53918454的博客
10-19 5203
从某个节点前面插入新节点比从后面插入要多进行一次判断，判断是否为头节点，另一个要注意的地方就是while里的判断条件是用p->next来判断的，这是因为我们可以通过p来找到p的后一个，但是找不到p的前一个，所以这里我们灵活变换一下，代码实现逻辑和从后面插入大同小异。删除一个节点实现逻辑也很好理解，肯定也是要不断遍历，找到对应节点后把原本指向它的结构体指针指向它的下一个，然后按道理我们要把它free掉，上面的代码就是实现尾插法创建链表，这种方式创建出链表中节点的顺序也就是我们正常所认为的顺序，最先的就是头。
数据结构 第一章 前置知识 链表
最新发布
12-16
4. **学习要求**：阅读者需要具备一定的C语言基础，特别是对指针和结构体的理解，建议参考郝斌的C语言教程来加强这些基础知识。 5. **代码展示**：文章提供了链表操作的示例代码，但作者强调代码是学习笔记性质，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值