当前位置： 首页 > news >正文

数据结构 -- 链表--双向链表的特点、操作函数

news 2025/8/22 13:15:41

双向链表的操作函数

DouLink.c
#include "DouLink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>/*** @brief 创建一个空的双向链表* * 动态分配双向链表管理结构的内存，并初始化头指针和节点计数* * @return 成功返回指向新链表的指针，失败返回NULL*/
DouLinkList *CreateDouLinkList()
{// 为链表管理结构分配内存DouLinkList *dl = malloc(sizeof(DouLinkList));if (NULL == dl){perror("CreateDouLinkList malloc");  // 分配失败时输出错误信息return NULL;}dl->head = NULL;  // 初始化头指针为空（空链表）dl->clen = 0;     // 初始化节点计数为0return dl;
}/*** @brief 在双向链表头部插入新节点* * 动态创建新节点，将数据存入节点并插入到链表头部* * @param dl 指向双向链表的指针* @param data 指向要插入的数据的指针* @return 成功返回0，失败返回1*/
int InsertHeadDouLinkList(DouLinkList *dl, DATATYPE *data)
{// 为新节点分配内存DouLinkNode *newnode = malloc(sizeof(DouLinkNode));if (NULL == newnode){perror("InsertHeadDouLinkList malloc\n");  // 分配失败时输出错误信息return 1;}// 复制数据到新节点memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;  // 初始化新节点的后继指针newnode->prev = NULL;  // 初始化新节点的前驱指针// 如果链表为空，直接将新节点作为头节点if (IsEmptyDouLinkList(dl)){dl->head = newnode;}// 否则将新节点插入到头部else{newnode->next = dl->head;       // 新节点的后继指向原头节点dl->head->prev = newnode;       // 原头节点的前驱指向新节点dl->head = newnode;             // 更新头指针为新节点}dl->clen++;  // 节点计数加1return 0;
}/*** @brief 在双向链表尾部插入新节点* * 动态创建新节点，将数据存入节点并插入到链表尾部* * @param dl 指向双向链表的指针* @param data 指向要插入的数据的指针* @return 成功返回0，失败返回1*/
int InsertTailDouLinkList(DouLinkList *dl, DATATYPE *data)
{// 如果链表为空，直接调用头部插入函数if (IsEmptyDouLinkList(dl)){return InsertHeadDouLinkList(dl, data);}// 否则在尾部插入else{// 为新节点分配内存DouLinkNode *newnode = malloc(sizeof(DouLinkNode));if (NULL == newnode){perror("InsertTailDouLinkList malloc\n");  // 分配失败时输出错误信息return 1;}// 复制数据到新节点memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;  // 新节点的后继为空（作为尾节点）newnode->prev = NULL;  // 初始化前驱指针// 找到当前尾节点DouLinkNode *tmp = dl->head;while (tmp->next)  // 遍历到最后一个节点{tmp = tmp->next;}// 将新节点链接到尾节点后newnode->prev = tmp;  // 新节点的前驱指向原尾节点tmp->next = newnode;  // 原尾节点的后继指向新节点}dl->clen++;  // 节点计数加1return 0;
}/*** @brief 在双向链表指定位置插入新节点* * 在链表的指定索引位置插入新节点，索引从0开始* * @param dl 指向双向链表的指针* @param data 指向要插入的数据的指针* @param pos 插入位置的索引* @return 成功返回0，失败返回1*/
int InsertPosDouLinkList(DouLinkList *dl, DATATYPE *data, int pos)
{int size = GetSizeDouLinkList(dl);// 检查位置是否合法if (pos < 0 || pos > size){printf("InsertPosDouLinkList pos error\n");return 1;}// 位置0等同于头部插入if (0 == pos){return InsertHeadDouLinkList(dl, data);}// 位置等于链表长度等同于尾部插入else if (size == pos){return InsertTailDouLinkList(dl, data);}// 中间位置插入else{// 为新节点分配内存，注意只能再此处为该新节点的分配内存，（因为如果上面的条件符合，调用头插或尾插函数时就会有分配内存这一操作，如果一开始就为该新节点分配内存可能会导致段错误）DouLinkNode *newnode = malloc(sizeof(DouLinkNode));if (NULL == newnode){perror("InsertPosDouLinkList malloc\n");  // 分配失败时输出错误信息return 1;}// 复制数据到新节点memcpy(&newnode->data, data, sizeof(DATATYPE));newnode->next = NULL;newnode->prev = NULL;// 找到要插入位置的节点DouLinkNode *tmp = dl->head;while (pos--)  // 移动到目标位置{tmp = tmp->next;}// 插入新节点newnode->next = tmp;            // 新节点的后继指向当前节点newnode->prev = tmp->prev;      // 新节点的前驱指向当前节点的前驱tmp->prev = newnode;            // 当前节点的前驱指向新节点newnode->prev->next = newnode;  // 当前节点原前驱的后继指向新节点}dl->clen++;  // 节点计数加1return 0;
}/*** @brief 显示双向链表中的所有节点数据* * 可以按照正向或反向遍历并打印链表中的所有数据* * @param dl 指向双向链表的指针* @param direct 遍历方向（正向或反向）* @return 成功返回0*/
int ShowDouLinkList(DouLinkList *dl, DIRECT direct)
{DouLinkNode *tmp = dl->head;// 正向遍历（从头部到尾部）if (DIR_FORWARD == direct){while (tmp)  // 遍历所有节点{// 打印节点数据printf("name:%s sex:%c age:%d score:%d\n", tmp->data.name, tmp->data.sex, tmp->data.age, tmp->data.score);tmp = tmp->next;  // 移动到下一个节点}}// 反向遍历（从尾部到头部）else{// 先移动到尾节点while (tmp->next){tmp = tmp->next;}// 从尾节点遍历到头部while (tmp){// 打印节点数据printf("name:%s sex:%c age:%d score:%d\n", tmp->data.name, tmp->data.sex, tmp->data.age, tmp->data.score);tmp = tmp->prev;  // 移动到前一个节点}}return 0;
}/*** @brief 判断双向链表是否为空* * @param dl 指向双向链表的指针* @return 链表为空返回1，不为空返回0*/
int IsEmptyDouLinkList(DouLinkList *dl)
{return 0 == dl->clen;  // 通过节点计数判断是否为空
}/*** @brief 按姓名查找双向链表中的节点（旧版实现，通过姓名直接匹配，可与函数指针回调版对比）* * 遍历双向链表，逐个对比节点中存储的姓名与传入的目标姓名，找到则返回对应节点指针，用于简单的按姓名精准查找场景。* 若后续有多样化查找需求（比如按年龄、分数等），更推荐用函数指针回调的通用查找方式（ FindDouLinkList 函数）。* * @param dl 指向要操作的双向链表管理结构的指针，通过它能访问链表头节点，进而遍历整个链表* @param name 要查找的目标姓名，以字符串形式传入，用于和链表节点中存储的姓名做对比* @return 找到匹配姓名的节点时，返回该节点的指针；遍历完链表未找到时，返回 NULL */
DouLinkNode *FindDouLinkList(DouLinkList *dl, char *name)
{DouLinkNode* tmp = dl->head;  // 从链表头节点开始遍历while (tmp)  // 只要当前节点指针不为空，就持续遍历{// 调用 strcmp 函数对比当前节点姓名和目标姓名，strcmp 返回 0 表示字符串相等if (0 == strcmp(tmp->data.name, name))  {return tmp;  // 找到匹配姓名的节点，返回该节点指针}tmp = tmp->next;  // 移动到下一个节点，继续遍历}return NULL;  // 遍历完所有节点都没找到匹配姓名的，返回 NULL
}/*** @brief 在双向链表中查找符合条件的节点* * 使用回调函数作为匹配条件，实现灵活的查找功能* * @param dl 指向双向链表的指针* @param fun 回调函数指针，用于判断节点是否符合条件* @param arg 传递给回调函数的参数，作为查找条件* @return 找到返回匹配节点的指针，未找到返回NULL*/
DouLinkNode *FindDouLinkList(DouLinkList *dl, PFUN fun, void *arg)
{DouLinkNode *tmp = dl->head;  // 从头部开始遍历while (tmp)  // 遍历所有节点{// 调用回调函数判断当前节点是否符合条件if (fun(&tmp->data, arg)){return tmp;  // 找到匹配节点，返回该节点指针}tmp = tmp->next;  // 移动到下一个节点}return NULL;  // 未找到匹配节点
}/*** @brief 反转双向链表* * 将双向链表的节点顺序反转，改变节点间的链接关系* * @param dl 指向双向链表的指针* @return 成功返回0，无需反转返回1*/
int ReverseDouLinkList(DouLinkList *dl)
{int size = GetSizeDouLinkList(dl);// 节点数小于2时无需反转if (size < 2){printf("No need to reverse (size < 2)\n");return 1;}DouLinkNode *cur = dl->head;  // 当前节点指针，从头部开始DouLinkNode *Prev = NULL;     // 保存前一个节点的指针while (cur != NULL){  DouLinkNode *tmp = cur->next;  // 保存下一个节点，防止断链cur->next = Prev;              // 反转当前节点的后继指针，指向前一个节点cur->prev = tmp;               // 反转当前节点的前驱指针，指向后一个节点Prev = cur;                    // 更新前一个节点指针cur = tmp;                     // 移动到下一个节点}dl->head = Prev;  // 反转后，原尾节点成为新的头节点return 0;
}/*** @brief 获取双向链表的节点数量* * @param dl 指向双向链表的指针* @return 返回链表中的节点数量*/
int GetSizeDouLinkList(DouLinkList *dl)
{return dl->clen;  // 直接返回节点计数值
}/*** @brief 修改双向链表中符合条件的节点数据* @param dl 双向链表的指针* @param fun 比较函数指针，用于查找目标节点* @param arg 传给比较函数的参数（用于指定查找条件）* @param newdata 指向新数据的指针，将用此数据替换找到节点的数据* @return 0表示修改成功，1表示修改失败（未找到节点）*/
int ModifyDouLinkList(DouLinkList *dl, PFUN fun, void *arg, DATATYPE *newdata)
{// 调用查找函数，根据fun和arg找到目标节点DouLinkNode *tmp = FindDouLinkList(dl, fun, arg);// 若未找到目标节点，打印错误信息并返回失败if (NULL == tmp){printf("ModifyDouLinkList failure failure\n");return 1;}// 将新数据拷贝到找到的节点中（覆盖原有数据）// 使用memcpy确保结构体所有成员都被正确替换memcpy(&tmp->data, newdata, sizeof(DATATYPE));// 修改成功，返回0return 0;
}/*** @brief 从双向链表中删除符合条件的节点* @param dl 双向链表的指针* @param fun 比较函数指针，用于查找目标节点* @param arg 传给比较函数的参数（用于指定查找条件）* @return 0表示删除成功，1表示删除失败（未找到节点）*/
int DeleteDouLinkList(DouLinkList *dl, PFUN fun, void *arg)
{// 调用查找函数，根据fun和arg找到目标节点DouLinkNode *tmp = FindDouLinkList(dl, fun, arg);// 若未找到目标节点，打印错误信息并返回失败if (NULL == tmp){printf("del failure\n");return 1;}// 情况1：删除的是头节点if (tmp == dl->head){// 将头指针指向原头节点的下一个节点dl->head = dl->head->next;// 若新头节点存在，需要将其prev指针置为NULL（断开与原头节点的联系）if (dl->head){dl->head->prev = NULL;}}// 情况2：删除的是中间节点或尾节点else{// 若当前节点不是尾节点，需要将下一个节点的prev指向当前节点的前一个节点if (tmp->next){tmp->next->prev = tmp->prev;}// 将当前节点前一个节点的next指向当前节点的下一个节点tmp->prev->next = tmp->next;}// 释放被删除节点的内存，避免内存泄漏free(tmp);// 链表长度减1dl->clen--;// 删除成功，返回0return 0;
}/*** @brief 销毁整个双向链表，释放所有分配的内存* @param dl 双向链表的指针* @return 0表示销毁成功*/
int DestroyDouLinkList(DouLinkList *dl)
{DouLinkNode *tmp = NULL;// 循环删除链表中的所有节点while (1){// 每次获取当前头节点tmp = dl->head;// 若头节点为NULL，说明所有节点已删除，退出循环if (NULL == tmp){break;}// 将头指针移动到下一个节点dl->head = dl->head->next;// 释放当前头节点的内存free(tmp);}// 释放链表结构体本身的内存free(dl);// 销毁成功，返回0return 0;
}

双向链表特点

双向链表（Doubly Linked List）是一种更复杂的链表，它的每个节点不仅包含指向下一个节点的指针（next），还包含指向前一个节点的指针（prev）。

  1. 双向遍历

    • 核心特点：可以从头节点开始向后遍历，也可以从尾节点开始向前遍历。这是其与单向链表最根本的区别。

  2. 节点结构

    • 每个节点包含三部分：

      • data: 存储数据。

      • next: 指针，指向下一个节点。

      • prev: 指针，指向前一个节点。

  3. 操作效率（与单向链表对比的核心优势）

    • 删除特定节点：在已知某个节点指针的情况下，双向链表可以在 O(1) 时间内删除该节点，因为它可以直接通过 prev 指针找到前驱节点。而单向链表需要从头遍历才能找到前驱节点，时间复杂度为 O(n)。

    • 在特定节点前插入：同样，在已知某个节点指针的情况下，双向链表可以在 O(1) 时间内完成在其前面的插入操作。单向链表无法直接做到，仍需遍历寻找前驱节点。

    • 反向遍历：需要反向遍历链表（例如，从大到小输出一个有序链表）时，双向链表非常高效。单向链表则非常笨拙，通常需要借助栈等辅助数据结构，或者先反转链表（这会修改原链表）。

  4. 缺点

    • 内存开销：每个节点都需要一个额外的指针来存储前驱节点的地址。对于节点数据本身很小的链表（例如，只存储一个整数），这个额外的指针开销占比会很大。

    • 操作复杂性：插入和删除节点时，需要维护两个方向的指针（next 和 prev），共需要修改 4 个指针（在某些边界情况下是 2 个）。而单向链表只需要修改 1 或 2 个指针。代码实现上更复杂，容易出错。

与单向链表的对比

特性单向链表 (Singly Linked List)双向链表 (Doubly Linked List)
节点结构data, nextdata, next, prev
遍历方向只能从头到尾单向遍历可以双向遍历（从头到尾或从尾到头）
内存占用更小（每个节点少一个指针）更大（每个节点多一个指针）
删除操作删除已知节点的前驱节点很高效 (O(1))
删除已知节点本身需要找前驱，效率低 (O(n))		删除已知节点本身非常高效 (O(1))
插入操作只能在已知节点后插入 (O(1))
在已知节点前插入需要找前驱，效率低 (O(n))		在已知节点前或后插入都非常高效 (O(1))
灵活性较低很高，前后移动都很方便
代码复杂度相对简单相对复杂，需要维护前后指针的完整性
http://www.dtcms.com/a/343417.html

相关文章：

  • EEA架构介绍
  • CH347 USB转JTAG芯片 SVF下载程序
  • pandas扩展：apply自定义函数、分组进阶（五大核心）、透视表
  • C6.0:晶体管放大器的原理与应用(基极偏置篇)
  • 单词记忆-轻松记忆10个实用英语单词（13）
  • 【openGauss】1分钟掌握：openGauss活动会话CPU占用率获取
  • Java获取被nginx代理的emqx客户端真实ip
  • STM32F030/070芯片解密及应用
  • DAY 23|动态规划1
  • LeetCode234~258题解
  • 深入解析JUC线程间通信：使用ReentrantLock与Condition实现精准线程调度
  • 32、智能仓库管理与优化系统 (模拟) - /物流与仓储组件/warehouse-optimization-system
  • IPSec 与 IKE 核心知识点总结
  • 使用Python 创建虚拟环境的两种方式
  • 订单簿数据深度学习方法在大单发现应用
  • 让医学数据更直观——MedCalc 23.1.7 最新版使用体验
  • sageattention低比特量化注意力机制,比FlashAttention快5 倍
  • DeepSeek-V3.1 Claude Code: 革命性的AI编码助手详解与应用指南
  • 论文图片在要求dpi下，压缩尺寸
  • ES_预处理
  • java18学习笔记-Simple Web Server
  • 美国联邦调查局警告俄罗斯针对思科设备的网络间谍活动
  • 残差神经网络（ResNet）
  • 矫平机与纵剪：一条钢卷“变身”的全过程
  • 【UE5-Airsim】Windows10下安装UE5-Airsim的仿真环境
  • leetcode 1658 将x减到0的最小操作数
  • 同题异构解决leetcode第3646题下一个特殊回文数
  • Linux网络socket套接字（上）
  • linux 之virtio 的驱动框架
  • Motocycle 智能仪表盘