数据结构2-单向链表

原创 已于 2025-08-05 14:16:41 修改 · 1k 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #链表相关操作 #链表的修改 #链表的排序 #链表的销毁 #查找链表元素、位置

于 2025-08-04 20:12:38 首次发布

摘要：本文详细介绍了链表的 11 种常见操作实现方法，包括链表元素查找、链表节点修改、尾插法插入节点、链表销毁、查找中间节点、查找倒数第 k 个节点、删除未知头节点的中间节点、链表倒置、链表冒泡排序、链表选择排序以及判断链表是否有环及环相关操作。每种操作均包含步骤说明和代码实现，涵盖了链表的基础操作与高级应用。

一、链表元素的查找

        在链表中找到指定的第一个元素

1、步骤：

  1. 沿用遍历思想，每次访问一个节点元素判断是否为要找的节点
  2. 符合条件返回该节点地址
  3. 到最后依旧没有找到符合条件的节点，返回NULL

2、代码实现：

1）函数体内容：

/* 找到符合要求的第一个元素节点地址 */
linknode *find_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;


        ptmpnode = phead->pnext;
        while (ptmpnode != NULL)
        {
                if (ptmpnode->data == tmpdata)
                {
                        return ptmpnode;
                }
                ptmpnode = ptmpnode->pnext;
        }


        return NULL;
}

2）main函数中的调用

// 返回值是指针地址，需要在main函数中设置一个变量去接收这个值

int main(void)

{

        linknode *p = NULL;

        p = find_linklist(plinklist);

        printf("%p\n",p);

        return 0;

}

二、链表的修改

1、步骤：沿用遍历思想，找到符合条件的元素修改为新的值

2、代码实现：

1）函数体内容：

/* 将符合条件的旧值修改为新值 */
int update_linklist(linknode *phead, datatype olddata, datatype newdata)
{
        linknode *ptmpnode = NULL;


        ptmpnode = phead->pnext;
        while (ptmpnode != NULL)
        {
                if (ptmpnode->data == olddata)
                {
                ptmpnode->data = newdata;
                 }
                ptmpnode = ptmpnode->pnext;
        }
        return 0;

}

2）main函数中的调用：

// 直接在main函数中调用，调用完后调用show_linklist函数就能看见结果

三、链表的尾插法

        在链表末尾插入一个元素

1、步骤：

  1. 申请节点空间
  2. 将数据存放到节点中
  3. 将节点中地址赋值为NULL
  4. 找到最后一个节点
  5. 最后一个节点的pnext赋值为新申请节点

2、代码实现：

1）函数体内容：

/* 尾插法插入节点元素 */
int insert_tail_linklist(linknode *phead, datatype tmpdata)
{
        linknode *ptmpnode = NULL;
        linknode *plastnode = NULL;


        //申请节点
        ptmpnode = malloc(sizeof(linknode));
        if (NULL == ptmpnode)
        {
                perror("fail to malloc")

                return -1;
        }


        //将节点空间中的元素赋值
        ptmpnode->data = tmpdata;
        ptmpnode->pnext = NULL;


        //找到最后一个节点元素
        plastnode = phead;
        while (plastnode->pnext != NULL)
        {
                plastnode = plastnode->pnext;
        }


        //将最后一个节点的pnext指向新申请节点
        plastnode->pnext = ptmpnode;
        return 0;
}

2）注意事项：

        如若是第一个插入链表的数据，其前一个phead->pnext是一个空(null)，无法链接后面，所以就直接设置将找到的最后一个链表节点直接指向下一个指针（ plastnode = phead;）

        这样无论是刚开始第一次使用尾插法还是在有链表节点元素后面插入都可以实现。

四、链表的销毁

        将所有的链表节点空间都释放掉

1、步骤：

  1. 定义两个指针pfreenode和ptmpnode都指向头结点
  2. ptmpnode向后走
  3. 再释放pfreenode指向的节点
  4. 再将pfreenode指向ptmpnode指向的空间

2、代码实现：

1）函数体内容：

/* 链表的销毁 */
int destroy_linklist(linknode **pphead)
{
        linknode *pfreenode = NULL;
        linknode *ptmpnode = NULL;


        ptmpnode = *pphead;
        pfreenode = *pphead;
        while (ptmpnode != NULL)
        {
                ptmpnode = ptmpnode->pnext;
                free(pfreenode);
                pfreenode = ptmpnode;
         }
        *pphead = NULL;


        return 0;

}

2）注意事项：

        链表的节点空间释放完我们需要将主函数的指针初始化（令其等于NULL），也要将该指针指向的空间地址也初始化。所以我们在传参数的时候需要给主函数的指针取地址，传二级指针过去。

main.c  destroy_linklist(&plinklist);

五、查找链表中间节点

1、步骤：

  1. 设置两个指针变量指向phead
  2. 快指针每次走2步，慢指针每次都1步
  3. 快指针走到末尾，慢指针走到中间

2、代码实现：

/* 查找链表中间节点 */
linknode *find_midnode(linknode *phead)
{
        linknode *pslow = NULL;
        linknode *pfast = NULL;


        pslow = pfast = phead->pnext;
        while (pfast != NULL)
        {
                pfast = pfast->pnext;
                if (NULL == pfast)
                {
                        break;
                }


                pfast = pfast->pnext;
                if (NULL == pfast)
                {
                        break;
                }
                pslow = pslow->pnext;
        }


        return pslow;
}

六、查找链表倒数第k个节点

1、步骤：

  1. 快指针先走k步
  2. 慢指针和快指针每次走一步
  3. 快指针到达末尾，慢指针少走k步，即倒数第k个元素

2、代码实现：

/* 查找链表倒数第k个节点 */
linknode *find_last_kth_node(linknode *phead, int k)
{
        int i = 0;
        linknode *pfast = NULL;
        linknode *pslow = NULL;

        pfast = phead->pnext;
        for (i = 0; i < k && pfast != NULL; i++)
        {
                pfast = pfast->pnext;
        }


        if (NULL == pfast)
        {
        return NULL;
        }


        pslow = phead->pnext;
        while (pfast != NULL)
        {
        pfast = pfast->pnext;
        pslow = pslow->pnext;
        }


        return pslow;
}

七、节点数据覆盖法 - 删除未知头节点地址的链表中间节点

1、步骤：

  1. 将指针指向的下一个节点的值覆盖当前节点的值
  2. 删除下一个节点

2、代码实现：

/* 删除指定节点 */
int delete_linknode(linknode *ptmpnode)
{
        linknode *pnextnode = NULL;


        pnextnode = ptmpnode->pnext;
        ptmpnode->data = pnextnode->data;
        ptmpnode->pnext = pnextnode->pnext;
        free(pnextnode);


        return 0;
}

八、链表倒置

1、步骤：

  1. 将原链表断开
  2. 将所有的元素依次使用头插法插入

2、代码实现

/* 链表倒置 */
int reverse_linklist(linknode *phead)
{
        linknode *pinsertnode = NULL;
        linknode *ptmpnode = NULL;  


        //将链表从头结点处断开
        ptmpnode = phead->pnext;
        phead->pnext = NULL;


        //依次将所有元素使用头插法插入链表中
        while (ptmpnode != NULL)
        {
                pinsertnode = ptmpnode;
                ptmpnode = ptmpnode->pnext;
                pinsertnode->pnext = phead->pnext;
                phead->pnext = pinsertnode;
        }


        return 0;
}

九、链表排序 - 冒泡排序

1、步骤：

  1. 采用冒泡排序思想，定义两个指针，相邻两个元素比较
  2. 指针循环向后走，直到ptmpnode2为NULL，即等于pend，循环停止
  3. pend赋值为tmpnode1的节点地址
  4. 下一轮就可以少比1次
  5. 循环将所有大的元素找到，剩余一个小的元素即可

2、代码实现：

/* 链表的冒泡排序 */
int bubble_sort_linklist(linknode *phead)
{
        linknode *ptmpnode1 = NULL;
        linknode *ptmpnode2 = NULL;
        linknode *pend = NULL;
        datatype tmpdata ;                //不初始化是因为是想通用性使用
        if (NULL == phead->pnext || NULL == phead->pnext->pnext )
        {
        return 0;
        }


        while (1)
        {
                ptmpnode1 = phead->pnext;
                ptmpnode2 = phead->pnext->pnext;
                if (pend == ptmpnode2)
                {
                        break;
                }


                while (ptmpnode2 != pend)
                {
                        if (ptmpnode1->data > ptmpnode2->data)
                        {
                                tmpdata = ptmpnode1->data;
                                ptmpnode1->data = ptmpnode2->data;
                                ptmpnode2->data = tmpdata;
                        }
                        ptmpnode1 = ptmpnode1->pnext;
                        ptmpnode2 = ptmpnode2->pnext;
                }
                pend = ptmpnode1;
        }
        return 0;
}

十、链表排序 - 选择排序

1、步骤：

  1. pswapnode指向要交换的节点
  2. pminnode假设的最小值
  3. ptmpnode和后续节点比较

2、代码实现：

/* 链表的选择排序 */
int select_sort_linklist(linknode *phead)
{
        linknode *pswapnode = NULL;
        linknode *ptmpnode = NULL;
        linknode *pminnode = NULL;
        datatype tmpdata;


        if (NULL == phead->pnext || NULL == phead->pnext->pnext)
        {
        return 0;
        }
        pswapnode = phead->pnext;


        while (pswapnode->pnext != NULL)
        {
                pminnode = pswapnode;
                ptmpnode = pswapnode->pnext;


                while (ptmpnode != NULL)
                {
                        if (ptmpnode->data < pminnode->data)
                        {
                                pminnode = ptmpnode;
                        }
                        ptmpnode = ptmpnode->pnext;
                }


                if (pswapnode != pminnode)
                {
                        tmpdata = pswapnode->data;
                        pswapnode->data = pminnode->data;
                        pminnode->data = tmpdata;
                }
                pswapnode = pswapnode->pnext;
        }


        return 0;
}

十一、判断链表是否有环

         判断链表是否有环、计算环的环长、找到环入口的位置

1、步骤：

  1.  链表是否有环：
    1. 定义两个指针：快指针（每次走2步）和慢指针（每次走1步）
    2. 快指针 - 慢指针 == 环长 即相遇，快指针和慢指针相等即为链表有环
  2. 计算环长：
    1. 定义一个指针从环相遇点开始走一圈，直到走该该节点为止
    2. 每走一个节点计数，最终可得到环长
  3. 获得环的入口位置：
    1. 公式推导出：a = c + (n-1)*l
    2. 定义一个指针从相遇点开始每次走一步，定义一个指针从开头每次走一步
    3. 两个指针相遇的位置即为环入口位置

2、代码实现

/* 1.判断链表是否有环
2.计算环长
3.找到环的入口位置
*/
int circle_linklist(linknode *phead, int *pis_circle, int *pcirlen, linknode **ppnode）

{
        linknode *pfast = NULL;
        linknode *pslow = NULL;
        linknode *ptmpnode = NULL;
        linknode *pstartnode = NULL;
        int cnt = 1;


        /* 判断是否有环 */
        pfast = phead->pnext;
        pslow = phead->pnext;
        while (1)
        {
                pfast = pfast->pnext;
                if (NULL == pfast)
                {
                        break;
                }


                pfast = pfast->pnext;
                if (NULL == pfast)
                {
                        break;
                }


                pslow = pslow->pnext;
                if (pfast == pslow)
                {
                        break;
                }
        }
        if (NULL == pfast)
        {
                *pis_circle = 0;
                return 0;
        }
        else
        {
                *pis_circle = 1;
        }


        /* 统计环长 */
        ptmpnode = pslow->pnext;
        while (ptmpnode != pslow)
        {
                cnt++;
                ptmpnode = ptmpnode->pnext;
        }
        *pcirlen = cnt;


        /* 找到环入口 */
        pstartnode = phead->pnext;
        ptmpnode = pslow;
        while (pstartnode != ptmpnode)
        {
                pstartnode = pstartnode->pnext;
                ptmpnode = ptmpnode->pnext;
        }

        *ppnode = ptmpnode;


        return 0;
}

数据结构--单向链表篇（python实现）
weixin_74068942的博客
07-10 1155
优点不需要预先知道数据大小，实现灵活的内存动态管理插入、删除指定数据速度快缺点读取指定位置数据速度慢空间开销比较大需要初始化node类(需要一个节点) 创建链表 插入节点 插入头节点 插入尾节点 获取数据 删除数据 遍历链表 写在最后
数据结构-单向链表教程.zip
08-24
本系列教程深入剖析链表数据结构，从基础概念到高级操作，全面覆盖。首先介绍链表的提出背景，随后通过单链表的ADT（抽象数据类型）模型，阐释其理论基础。接着，通过实际代码演示单链表及结点的定义，以及如何实现...
数据结构-单向链表(C语言)
m0_49408252的博客
07-22 2098
snode_t;为使链表具有通用性，在节点中只定义指针部分，数据部分通过自定义结构体的方式定义。char* name;node使得my_data_t可作为节点链接在链表中，my_data_t中数据可随实际情况改变。} slist_t;单向链表中定义head和tail分别指向链表的头和尾。
数据结构--单向链表的基本实现详解（java）
qq_74056922的博客
07-05 1090
每获取到一个节点就是用count++进行计数。cur指向头节点，在while循环中对整个链表进行遍历操作。//求当前列表节点个数while(cur!由代码可以看到，每次循环变量count就会进行自增操作用来记录链表的节点个数，最后返回的count就是链表的节点个数。
数据结构-单向链表
gurentongxinyyds的博客
07-05 963
本文介绍了链表这种线性数据结构，重点讲解了单向带头结点链表的实现。链表通过指针连接离散节点，相比顺序表具有动态内存分配优势，插入删除操作仅需修改指针指向（O(1)时间）。文章详细剖析了链表节点结构（数据域+指针域），并给出C语言实现代码，包括创建链表、头插法/任意位置插入、查找元素、删除节点等核心操作。特别强调了辅助指针在链表操作中的关键作用，通过图示说明插入和删除时的指针调整逻辑。最后比较了链表与顺序表的优缺点，指出链表更适合频繁插入删除但随机访问较慢的场景。
数据结构 -- 链表详解
hu_143的博客
04-27 3526
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构-单向循环链表
没出过地球
06-11 2737
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
结构体和数据结构--动态数据结构体-单向链表
ww1425408527的博客
07-10 1140
第2部分是一个结构体指针，称为链表的指针域，用于存储其直接后继的节点信息，这里用next表示，next的值实际上就是下一个节点的地址，即next指向下一个节点，当前节点为末节点时，next的值设为空指针（NULL），表示链表的结束。（3）若在链表中间插入新节点，则将新节点的指针域指向下一节点（p->next = pr->next），且让前一节点的指针域指向新节点（pr->next = p）。注意：节点被删除后，指标是将它从链表中断开而已，它仍然占用内存，必须释放其所占的内存，否则将出现内存泄漏。
【数据结构】超详细--单向链表
joes_ju的博客
11-14 907
保姆级，超详细的C语言来实现数据结构的单向非循环链表功能
基本数据结构-单向链表
leaf_lucky的博客
11-03 893
数据结构基础--单向链表
数据结构----链表
新手嵌入式学习的博客
08-16 2678
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构与算法-单向链表结构设计学生信息管理系统设计.docx
08-25
首先，文档提及的单向链表是一种常见的数据结构，用于存储数据元素序列。在学生信息管理系统中，每个链表节点包含学生的基本信息，如学号、姓名、年龄、电话和成绩等。节点之间通过指针链接，形成一个链式存储结构，...
数据结构——五十二、散列函数的构造(王道408)
2301_80201235的博客
11-23 929
本文总结了设计散列函数的注意事项和常用方法。设计散列函数时需注意：定义域覆盖所有关键字、值域不越界、减少冲突、计算简单。主要方法包括：除留余数法（取不大于表长的最大质数）、直接定址法（适用于连续关键字）、数字分析法（选取分布均匀的数码位）、平方取中法（取平方值的中间位）。其中重点阐述了除留余数法对质数取余可减少冲突的原因，并通过具体示例说明了各方法的适用场景和实现要点。这些方法可根据关键字特性选择使用，以达到均匀分布和高效存储的目的。
高阶数据结构 --- 单调栈
最新发布
2403_88695928的博客
11-23 250
本文介绍了算法竞赛中常用的单调栈数据结构。内容涵盖单调栈的基本概念（包括单调递增栈和单调递减栈）、主要作用以及相关算法题示例。通过三个典型题目（单调栈模板题、发射站问题、柱状图最大矩形面积问题）展示了单调栈的实际应用。文章以简明扼要的方式呈现了单调栈的核心知识点和应用场景。
ts-属性修饰符，接口(约束数据结构)，抽象类(约束与复用逻辑)
岂不闻
11-23 763
类的基础知识，抽象类与接口(interface)对比，interface接口实现约束数据结构（组件通信传参，定义口返回数据结构），抽象类(约束数据结构以及复用逻辑)
堆结构与堆排序
越安静，听到的就越多
11-22 520
虽然堆是用完全二叉树表示的，但在使用时通常用一个数组来存储。以数组的下标来标识堆中的节点，并且可以根据下标来获得某一节点的父节点和左右子节点。对于下标为i的节点，其父节点为(i - 1) / 2，其左子节点为2 * i + 1，右子节点为2 * i + 2。我们定义一个节点的高度为从该节点到叶子节点的最长简单向下路径的边数。树的高度就是根节点的高度。对于具有n个元素的数组，将其看作完全二叉树的话，树的高度为lgn。同时可以看到，对于大小为n的堆，n/2为该堆的第一个叶子节点。
数据结构：双向链表（3）
2401_86982201的博客
11-23 1239
本文介绍了四种链表经典算法题的解题思路和实现方法：1. 链表的中间节点 - 使用快慢指针法（时间复杂度O(n)，空间复杂度O(1)）；2. 合并两个升序链表 - 通过双指针比较和拼接（时间复杂度O(m+n)）；3. 链表分割 - 创建两个子链表分别存储小于x和大于等于x的节点；4. 链表回文结构 - 将链表值存入数组后使用双指针验证。文章详细解析了每种算法的核心思路、代码实现和复杂度分析，重点讲解了快慢指针、双指针比较等链表操作技巧，适用于理解链表操作的核心思想。
数据结构入门：栈的链式结构，告别固定容量的灵活选择
2503_93893479的博客
11-23 907
本文介绍了栈的链式结构（链栈）的实现原理和操作方式。链栈通过单链表实现，每个节点包含数据和指向下一节点的指针，栈顶对应链表表头。相比顺序栈，链栈具有容量灵活、内存利用率高的优势，但存在额外指针开销。文章详细讲解了链栈的节点结构定义、初始化、入栈、出栈等核心操作，并提供了C语言代码示例。链栈适合元素数量不确定、内存资源紧张等场景，其入栈出栈时间复杂度均为O(1)。文章最后对比了链栈与顺序栈的优缺点，建议根据实际需求选择合适实现方式。
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值