C语言拾遗——链表

最新推荐文章于 2022-08-07 21:28:39 发布
最新推荐文章于 2022-08-07 21:28:39 发布
阅读量349 收藏 1
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dbsdzxq/article/details/79440035
版权

C语言拾遗——链表

本篇主要讲述链表的创建，增、删、改、查、反逆、排序等操作。

链表是一种常见的重要的数据结构;它是动态地进行存储分配的一种结构.每一个节点包含两部分，数据和指向下一个节点地址的指针，各节点之间的地址不连续是链表不同于数组的最大特性。
这里写图片描述
简单链表：
s

truct Student
{  int num;
　 float score;
　 struct Student *next; 
}a,b,c;     //建立一个简单链表，它由3个学生数据的结点组成

所谓建立动态链表是指在程序执行过程中从无到有地建立起一个链表，即一个一个地开辟结点和输入各结点数据，并建立起前后相链的关系。链表的建立一般是指先建立一个空链表，而后一个个地将元素插在队尾。

一、C语言实现创建链表代码

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

struct student
{
    int num;
    float score;
    struct student *pNext;

};
typedef  struct student ST;     //简写结构体声明
//添加链表元素，先建立一个空链表，而后一个个地将元素插在队尾。

void add(ST **phead, int inum, float iscore)
{
    if (*phead == NULL)     //判断链表是否为空
    {
        ST *newnode = (ST *)malloc(sizeof(ST));     //分配内存
        if (newnode==NULL)
        {
            printf("内存分配失败");
            return;
        }
        newnode->num = inum;                //节点初始化
        newnode->score = iscore;
        newnode->pNext = NULL;

         *phead=newnode;        //让头指针指向这个节点

    }
    else        //链表不为空，尾部插入的方式
    {
        ST *p = *phead;             //指向头节点
        while (p->pNext != NULL)            //循环到最后一个节点的地址
        {
            p = p->pNext;               //不断循环向前
        }

        ST *newnode = (ST *)malloc(sizeof(ST));     //分配内存
        if (newnode == NULL)
        {
            printf("内存分配失败");
            return;
        }
        newnode->num = inum;                //节点初始化
        newnode->score = iscore;
        newnode->pNext = NULL;

        p->pNext = newnode;             //链接上
    }
}

//显示链表元素
void showall(ST *head)
{
    ST *pb = head;
    while (pb != NULL)
    {
        printf("\n%d,%f", pb->num, pb->score);
        printf("     %p,%p  ", pb, pb->pNext);      //打印两个节点的地址
        pb = pb->pNext;         //指针不断向前循环

    }
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);
    //也可以通过下面这种方式来访问
    printf("\n%d,%f", head->num, head->score);
    printf("\n%d,%f", head->pNext->num, head->pNext->score);
    printf("\n%d,%f", head->pNext->pNext->num, head->pNext->pNext->score);

    system("pause");
}

二、查找链表元素
类似数组操作，传入链表头指针，进行比对，没有找到就不停的向前移动，直到队尾。

ST * search(ST *head, int num)      //根据编号查找结点
{
    while (head != NULL)
    {
        if (num == head->num)
        {
            return head;
        }
        head = head->pNext;         //  指针不断向前循环
    }
    return NULL;                    //返回为空
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    ST *psearch = search(head, 5);
    if (psearch == NULL)
    {
        printf("\n没有找到");
    }
    else
        printf("\n%d,%f", psearch->num, psearch->score);            //打印链表指针指向的地址

     psearch = search(head, 3);
    if (psearch == NULL)
    {
        printf("\n没有找到");
    }
    else
        printf("\n找到%d,%f", psearch->num, psearch->score);          //打印链表指针指向的地址

    system("pause");
}

三、改变链表元素的值
这个操作建立在查找的基础上，就像数组中修改一个数组元素一样，链表的修改也很简单，找到元素，重新赋值就好了。

void change(ST *head, int oldnum, int newnum)           //查找oldnum,修改newnum
{
    ST *psearch = search(head, oldnum);
    if (psearch == NULL)
    {
        printf("没有找到");
    }
    else
    {
        psearch->num = newnum;
        printf("修改成功");
    }
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    printf("\n改变后\n");
    change(head, 3, 33);
    showall(head);

    system("pause");
}

四、插入链表节点
分为两种，在节点之前插入和在节点后面插入两种方式，在节点前面插入，如果在第一个元素p1前插入，那就让np的指向为p1，再让头指针指向要插入的节点np的地址就可以了。如果在中间插入，那就先让np的指向等于px的指向，再让px的指向为np就可以了，如图所示
这里写图片描述
同理在节点后面插入，如果这个节点是最后一个，就把新节点的指向改为NULL，再把最后一个的指向改为新节点的地址，如果在中间插入，就让新节点np的指向要插入节点px的指向，再让px的指向为np就可以了，如图所示

这里写图片描述

代码如下

ST *Headinset(ST *head, int num, int inum, float iscore)        //根据节点，在节点前插入
{
    ST*p1, *p2;
    p1 = p2 = NULL;
    p1 = head;
    while (p1 != NULL)
    {
        if (p1->num == num)     //判定相等
        {
            break;
        }
        else
        {
            p2 = p1;
            p1 = p1->pNext;     //循环到下一个节点
        }
    }

    if (head == p1)     //头节点
    {
        ST* newnode = (ST *)malloc(sizeof(ST));     //分配内存
        newnode->num = inum;
        newnode->score = iscore;
        newnode->pNext = p1;                //指向第一个节点
        head = newnode;                     //newnode成为第一个节点
    }
    else
    {
        ST* newnode = (ST *)malloc(sizeof(ST));     //分配内存
        newnode->num = inum;
        newnode->score = iscore;
        newnode->pNext = p1;                //新节点指向p1
        p2->pNext = newnode;                //指向新节点
    }
    return head;
}

ST *Backinset(ST *head, int num, int inum, float iscore)        //根据节点，在节点后插入
{
    ST*p1, *p2;
    p1 = p2 = NULL;         //对节点置空
    p1 = head;
    while (p1 != NULL)      //一直循环到最后一个节点
    {
        if (p1->num == num)     //判定相等
        {
            break;
        }
        else
        {
            p2 = p1;
            p1 = p1->pNext;     //循环到下一个节点
        }
    }

    if (p1->pNext == NULL)      //最后一个节点 
    {
        ST* newnode = (ST *)malloc(sizeof(ST));     //分配内存
        newnode->num = inum;
        newnode->score = iscore;
        newnode->pNext = NULL;              //指针与此时为空，最后一个节点的指向为NULL
        p1->pNext = newnode;                        //指向新开辟的节点
    }
    else
    {
        p2 = p1->pNext;         //记录下一个节点的位置
        ST* newnode = (ST *)malloc(sizeof(ST));     //分配内存
        newnode->num = inum;
        newnode->score = iscore;
        newnode->pNext = p2;                //链接下一个节点
        p1->pNext = newnode;                //p1指向新节点
    }
    return head;            //没有改变head,卵用不大
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    printf("\n从前插入\n");
    head = Headinset(head, 2, 5, 76);       //在2前面插入5   
    showall(head);
    printf("\n从后插入\n");
    head = Backinset(head, 3, 5, 76);       //在3后面插入5
    showall(head);

    system("pause");
}

五、删除链表节点
链表节点的删除也比数组简单，找到指定节点p后，让前一个节点p-1的指向改为p的指向，也就是p+1的地址，然后free（p）就完成节点p的删除了。如图

这里写图片描述
代码如下

ST* delete(ST * head,int num)
{
    ST *p1, *p2;
    p1 = p2 = NULL;
    p1 = head;      //从头结点开始循环
    while (p1 != NULL)
    {
        if (p1->num == num)     //判断是否相等
        {
            break;          //相等跳出循环
        }
        else
        {
            p2 = p1;        //记录当前结点
            p1 = p1->pNext;
        }
    }
    if (p1 == head)
    {
        head = p1->pNext;   //跳过头节点
        free(p1);       //释放第一个节点
    }
    else 
    {
        p2->pNext = p1->pNext;      //跳过了p1;
        free(p1);           //释放节点
    }
    return head;        //返回头节点的值
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    printf("\n删除后\n");
    delete(head, 3);
    showall(head);

    system("pause");
}

总结：
链表的增加，删除，不需要移动，直接操作。
查询与修改，无法像数组定位位置，需要用循环的方式来定位

下面再说说链表的逆转与排序
链表的逆置，是指“头变尾，尾变头”，将原来的“ABCD……”变成“……DCBA”，先从单链表模型来看 如图所示，链表的逆置实际就是改变结构体中的指针，指向上一个地址即可。
这里写图片描述
其主要代码如下：

ST *rev(ST *head)
{
    ST *p1, *p2, *p3;
    p1 = p2 = p3 = NULL;
    if (head == NULL || head->pNext == NULL)        //如果空链表或者只有一个节点
    {
        return head;        //返回头节点
    }
    p1 = head;
    p2 = head->pNext;
    while (p2 != NULL)      //从第二个到最后一个节点进行循环
    {
        p3 = p2->pNext;         //布局三个节点
        p2->pNext = p1;         //指向前面一个节点\

        p1 = p2;                //指针向前移动，从第二个到最后一个节点全部指向前面的节点
        p2 = p3;
    }
    head->pNext = NULL;     //代表链表的结束，设置第一个节点指向为空
    head = p1;              //当p2=NULL时，p1指向最后一个节点
    return head;        //副本机制，改变的head，并不会生效，需要返回值赋值 
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    printf("\n逆转后\n");
    head=rev(head);             //逆转链表
    showall(head);

    system("pause");
}

链表的排序
由于链表不能随便访问的特性，决定了链表的排序适合冒泡排序法，不适合选择排序等。
我们按照输入的要求实现不同的排序，当输入>时，按照从大到小排序；当输入<时实现从小到大排序。
用冒泡排序链表和进行数组排序的思路一样，两层for循环，外层每循环一次就一个极值沉底，共循环n-1次，内层循环进行相邻节点大小的比较及交换。代码如下

void sort(ST *head, char ch)            //ch='>'时，从大到小排序，ch='<'时从小到大排序
{
    if (ch == '>')          //从大到小排序
    {
        for (ST *p1 = head;p1 != NULL;p1 = p1->pNext)       //外层的循环，只能遍历所有的情况，数组可以规避一些无意义的，链表就要全部刷一遍
        {
            for (ST *p2 = head;p2 != NULL;p2 = p2->pNext)
            {
                if (p1->num > p2->num)
                {
                    ST tmp;
                    tmp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = tmp.num;
                    tmp.score = p1->score;
                    p1->score = p2->score;
                    p2->score = tmp.score;
                }
            }
        }
    }
    else if(ch == '<')      //从小到大排序
    {
        for (ST *p1 = head;p1 != NULL;p1 = p1->pNext)
        {
            for (ST *p2 = head;p2 != NULL;p2 = p2->pNext)
            {
                if (p1->num < p2->num)
                {
                    ST tmp;
                    tmp.num = p1->num;
                    p1->num = p2->num;
                    p2->num = tmp.num;
                    tmp.score = p1->score;
                    p1->score = p2->score;
                    p2->score = tmp.score;
                }
            }
        }
    }
}
void main()
{
    struct  student *head = NULL;   //头节点指针  

    add(&head, 1, 70);
    add(&head, 2, 80);
    add(&head, 3, 90);
    add(&head, 4, 100);
    showall(head);

    printf("\n从大到小排序后\n");
    sort(head, '>');
    showall(head);

    printf("\n小到大排序后\n");
    sort(head, '<');
    showall(head);

    system("pause");
}
dbsdzxq
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
408 | 考前知识拾遗
"You are worthy! You can do it!"
12-19 2245
DNSgetIP地址、建立TCP连接、发送报文、四次挥手一系列过程。2、报文字段、切分分组子网、子网掩码。1、网关配置、路由表、网络可达性。在⼀棵红⿊树中，如果所有结点都是⿊的，那么它的形态⼀定是满⼆叉树。选择题、⼤题简答题中可能出现的考法：给你⼀段C。复习虚拟⽂件系统、⽂件系统挂载的基础课课件。潜在考点：平衡二叉树 画图、树和森林 孩子兄弟数据结构。TCP协议：三次握手、四次挥手。虚拟⽂件系统、⽂件系统的挂载。红黑树、并查集（克鲁斯卡尔、环路、连通分量）数据交换方式——怎么算时间。
动态插入节点
啦啦啦
07-25 505
输入L, R来放入带插入的二叉树中, 如:LLLL代表将数插入到 左左左左的位置, LRLRLR也同理, 只需要将输入的放在字符串中一个一个读取即可
动态建立链表
a514223963的专栏
07-11 9877
所谓动态链表是指在程序执行过程中从无到有地建立起一个链表，既一个一个地开辟结点和输入各结点的数据，并建立起前后相连的关系。 例题： #include using namespace std; #define NULL0     struct student {long num; float score; struct student *next; }; int main()
现代C语言技术2
qq_40500005的博客
09-16 674
C语言语法拾遗 专门总结了一些C语言C99/C11之后的新语法或冷门语法 预处理和宏——灵魂 预处理器和宏可以说是面向对象语言独有的东西，这些特性发生在编译这个过程之前，使得C语言的编译过程变得“可控”，甚至可以说C语言编译本身就是一个开发者可编程的过程——或许这样说比较抽象，举个例子：java的宏并不对一般开发者开放，一般只有OpenJDK的开发者才会面对java宏和相关预编译指令；但是C语言的宏直接出现在hello world程序中：“#include”指令本身就意味着对链接器进行调用——这些宏严格来说
C基本知识点拾遗
basycai的博客
01-05 1344
最近需要学习C语言，找了些C容易犯错的知识点和重点，以提示自己。 总体上必须清楚的:  1)程序结构是三种:  顺序结构 、选择结构(分支结构)、循环结构。  2)读程序都要从main()入口, 然后从最上面顺序往下读(碰到循环做循环,碰到选择做选择)，有且只有一个main函数。  3)计算机的数据在电脑中保存是以二进制的形式. 数据存放的位置就是 他的地址.  4)bit是位
【数据结构与算法】---链表
weixin_67900732的博客
08-04 4009
今天小编带大家学习数据结构中的链表。
JAVA基础拾遗
Hello Turing-Tang
03-16 408
最近在面试的时候总是做一些很基础的问题，但是我的回答总是模棱两可，自己都不太确定，所以在这里做一下java基础的复习。 首先、基础数据类型： java一共有8种基础类型，4种整形、2种浮点型、1种 char类型用于表示Unicode编码、1种表示boolean类型。 四种整型： 1. byte 1字节 8位-128~127 2.
【数据结构与算法】---OJ题库来源力扣牛客
weixin_67900732的博客
08-07 286
链表OJ习题来源力扣
【数据结构与算法】顺序表
weixin_67900732的博客
08-02 1421
每个人的成长都是能力和想要得到的东西，不断匹配的过程，当你的才华和欲望不匹配时，你就该静下心来学习了，如果小编的总结能对你有所帮助，希望小伙伴们三连加关注哦，你的支持是小编创作的最大动力。...
C语言——链表的归并_c语言链表详解
12-21
标题“C语言——链表的归并_c语言链表详解”和描述“用c语言写链表归并”明确指出了本文的主要内容：使用C语言实现链表的归并操作，并对C语言中的链表进行详细讲解。 #### 代码解析 ##### 1. 结构体定义 ```c ...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
针对在校大学生的C语言入门学习——链表源码
01-26
【标题】"针对在校大学生的C语言入门学习——链表源码"，旨在为初学者提供C语言中链表数据结构的基本概念和实现方法。链表是计算机科学中一种重要的抽象数据类型，它与数组不同，不连续存储元素，而是通过指针链接...
C语言游戏——死神vs火影
11-21
2. **指针**：作为C语言的核心特性，指针用于高效地操作内存，实现复杂的数据结构如链表、树等。 3. **结构体与联合**：结构体可以封装多个不同类型的变量，联合则允许在相同内存空间内存储不同类型的值，用于实现...
C语言实现多种链表快速排序
05-08
在C语言中实现链表快速排序，首先需要理解链表和快速排序的基本概念。链表不同于数组，它不连续存储数据，而是通过指针连接各个节点。每个节点包含数据元素和指向下一个节点的指针。快速排序的核心是“分区操作”和...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现蝗虫优化算法GOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
C语言详解：链表基础与操作
【C语言链表详解】 C语言中的链表是一种动态数据结构，它允许数据的动态分配和重新组织，不同于数组的静态存储方式。链表主要由一系列称为"结点"的数据结构组成，每个结点包含两个域：数据域用于存储数据，而指针域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值