双向链表C语言（非伪代码）

已于 2024-10-03 16:28:42 修改
阅读量1.1k 收藏 11
点赞数 36
文章标签： 链表 c语言 数据结构
于 2024-10-03 16:28:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79365218/article/details/142692378
版权

对于双向链表来说，其实和单向链表差别不大，只要你了解单向链表的底层逻辑，实现双向链表其实很简单。

一、双向链表的结点/链表

typedef struct ListNode { // 双向链表的节点
    int data; // 数据域
    struct ListNode* next; // 后继指针
    struct ListNode* prev; // 前驱指针
} ListNode;

typedef struct LinkedList { // 完整的双向链表
    ListNode* head; // 头节点
    int len; // 链表长度
} LinkedList;

二、初始化/创建一个双向链表

与单向链表一致

void Creat_LinkedList(LinkedList* list) // 初始化链表
{
    list->head = NULL;
    list->len = 0;
}

三、销毁链表

与单链表一致

void Destroy_LinkList(LinkedList* list) // 销毁链表
{
    while (list->head)
    {
        ListNode* temp = list->head; // 缓存当前头节点
        list->head = list->head->next; // 移动头指针
        free(temp); // 释放当前节点
    }
    list->len = 0;
}

四、在双向链表中插入元素

4.1、核心代码实现

  • 与单链表一样，分为头插法与尾插法。
  • 与单链表相比，多了两条语句，即prev相关的语句，但难度不大
  • 顺序：先把新结点的链表中的结点建立联系--->再把链表中的结点指向进行修改
// 在链表中插入元素
void Insert_LinkList(LinkedList* list, int i, int value)//第i个位置插入值为value的元素
{
    if (i < 0 || i > list->len) // 越界检查
    {
        printf("插入失败\n");
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = value;

    if (i == 0) // 在头部插入
    {
        newNode->next = list->head; // 新节点指向原头节点
        newNode->prev = NULL; // 新节点前驱为空
        if (list->head) // 如果链表非空，更新原头节点的前驱指针
        {
            list->head->prev = newNode;
        }
        list->head = newNode; // 更新头节点
    }
    else // 插入到其他位置
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) // 找到插入位置的前一个节点
        {
            current = current->next;
        }
        newNode->next = current->next; // 新节点的后继为current的后继
        newNode->prev = current; // 新节点的前驱为current

        if (current->next) // 如果current后有节点，更新其前驱指针
        {
            current->next->prev = newNode;
        }
        current->next = newNode; // 更新current的后继为新节点
    }
    list->len++;
}

4.2、算法图解

4.2.1、当链表为空时

  • 对单结点进行操作，prev与next都置空
  • 头节点指向单节点

4.2.2、插入节点为头节点，但链表不为空时

  • 先让新节点和链表节点搭上线（步骤1/2）
  • 修改链表节点的指向（步骤3)
  • 修改头指针的指向

4.2.3、插入的节点不为头节点时

  • 定义迭代器，找到需要插入的节点位置的前一个结点
  • 让我们需要插入的结点与链表搭上线（步骤3/4）
  • 修改链表元素指向（5/6）

  • 温馨提醒：如果插入为尾结点，则去掉步骤5，因为cur->next=NULL。而步骤3自动变成newNode->next=NULL

五、在双向链表中删除节点

5.1、核心代码实现：

  • 需要一个变量toDelete用来最后的释放节点
  • 当然，如果不为头节点时，同时也需要一个迭代器实现删除节点的查找
// 删除节点
void Delete_LinkList(LinkedList* list, int i)
{
    if (i < 0 || i >= list->len) // 越界检查
    {
        printf("删除失败\n");
        return;
    }

    ListNode* toDelete = list->head;

    if (i == 0) // 删除头节点
    {
        list->head = toDelete->next; // 头节点后移
        if (list->head) // 更新新头节点的前驱指针
        {
            list->head->prev = NULL;
        }
        free(toDelete); // 释放旧头节点
    }
    else // 删除其他节点
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) // 找到删除位置的前一个节点
        {
            current = current->next;
        }
        toDelete = current->next; // 要删除的节点
        current->next = toDelete->next; // 前一个节点的后继指向要删除节点的后继

        if (toDelete->next) // 如果删除节点的后继存在，更新其前驱
        {
            toDelete->next->prev = current;
        }
        free(toDelete); // 释放要删除的节点
    }
    list->len--;
}

5.2算法图解：

5.2.1、删除节点为头节点

  • 定义一个toDelete指向头节点（步骤1，为释放做准备）
  • 移动头节点指向（步骤2）
  • 修改节点指向（步骤2就是为了这步做准备，不然访问不到这个节点）
  • 释放toDelete节点（步骤4）

5.2.2、删除的节点不是头节点：

  • 删除指向toDelete，迭代器cur（步骤1234）
  • 修改cur的next节点，断开cur->next与toDelete的关系，建立起与toDelete->next的关系（步骤5）
  • 修改toDelete->prev的节点指向，断开toDelete->prev与toDelete的关系，建立起与cur的关系（步骤6）

步骤5/6使得toDelete与链表完全断开联系

  • 释放toDelete所指向的节点

六、通过元素来查找链表节点

与单链表没差别，不再赘述

// 通过元素查找节点
ListNode* Find_element_Linked(LinkedList* list, int value)
{
    ListNode* current = list->head; // 迭代器从头开始

    while (current) // 遍历链表
    {
        if (current->data == value) // 找到元素
        {
            return current;
        }
        current = current->next; // 继续下一个节点
    }
    return NULL; // 没有找到
}

七、通过下标来查找链表节点

与单链表没差别，不再赘述

// 通过下标查找节点
ListNode* Find_Index_Linked(LinkedList* list, int i)
{
    if (i < 0 || i >= list->len) // 越界检查
    {
        printf("寻找错误\n");
        return NULL;
    }

    ListNode* current = list->head;

    for (int j = 0; j < i; j++) // 遍历到第i个节点
    {
        current = current->next;
    }
    return current;
}

八、更新链表元素

// 更新链表元素
void Update_LInked(LinkedList* list, int i, int value)
{
    ListNode* temp = Find_Index_Linked(list, i);

    if (temp) // 如果节点存在
    {
        temp->data = value; // 更新数据
    }
}

九、打印链表

// 打印链表
void Print_Linked(LinkedList* list)
{
    ListNode* current = list->head;

    while (current)
    {
        printf("%d <-> ", current->data); // 打印当前节点
        current = current->next; // 移动到下一个节点
    }
    printf("NULL\n");
}

十、完整的代码实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

typedef struct ListNode { // 双向链表的节点
    int data; // 数据域
    struct ListNode* next; // 后继指针
    struct ListNode* prev; // 前驱指针
} ListNode;

typedef struct LinkedList { // 完整的双向链表
    ListNode* head; // 头节点
    int len; // 链表长度
} LinkedList;

void Creat_LinkedList(LinkedList* list) // 初始化链表
{
    list->head = NULL;
    list->len = 0;
}

void Destroy_LinkList(LinkedList* list) // 销毁链表
{
    while (list->head)
    {
        ListNode* temp = list->head; // 缓存当前头节点
        list->head = list->head->next; // 移动头指针
        free(temp); // 释放当前节点
    }
    list->len = 0;
}

// 在链表中插入元素
void Insert_LinkList(LinkedList* list, int i, int value)//第i个位置插入值为value的元素
{
    if (i < 0 || i > list->len) // 越界检查
    {
        printf("插入失败\n");
        return;
    }

    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = value;

    if (i == 0) // 在头部插入
    {
        newNode->next = list->head; // 新节点指向原头节点
        newNode->prev = NULL; // 新节点前驱为空
        if (list->head) // 如果链表非空，更新原头节点的前驱指针
        {
            list->head->prev = newNode;
        }
        list->head = newNode; // 更新头节点
    }
    else // 插入到其他位置
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) // 找到插入位置的前一个节点
        {
            current = current->next;
        }
        newNode->next = current->next; // 新节点的后继为current的后继
        newNode->prev = current; // 新节点的前驱为current

        if (current->next) // 如果current后有节点，更新其前驱指针
        {
            current->next->prev = newNode;
        }
        current->next = newNode; // 更新current的后继为新节点
    }
    list->len++;
}

// 删除节点
void Delete_LinkList(LinkedList* list, int i)
{
    if (i < 0 || i >= list->len) // 越界检查
    {
        printf("删除失败\n");
        return;
    }

    ListNode* toDelete = list->head;

    if (i == 0) // 删除头节点
    {
        list->head = toDelete->next; // 头节点后移
        if (list->head) // 更新新头节点的前驱指针
        {
            list->head->prev = NULL;
        }
        free(toDelete); // 释放旧头节点
    }
    else // 删除其他节点
    {
        ListNode* current = list->head;

        for (int j = 0; j < i - 1; j++) // 找到删除位置的前一个节点
        {
            current = current->next;
        }
        toDelete = current->next; // 要删除的节点
        current->next = toDelete->next; // 前一个节点的后继指向要删除节点的后继

        if (toDelete->next) // 如果删除节点的后继存在，更新其前驱
        {
            toDelete->next->prev = current;
        }
        free(toDelete); // 释放要删除的节点
    }
    list->len--;
}

// 通过元素查找节点
ListNode* Find_element_Linked(LinkedList* list, int value)
{
    ListNode* current = list->head; // 迭代器从头开始

    while (current) // 遍历链表
    {
        if (current->data == value) // 找到元素
        {
            return current;
        }
        current = current->next; // 继续下一个节点
    }
    return NULL; // 没有找到
}

// 通过下标查找节点
ListNode* Find_Index_Linked(LinkedList* list, int i)
{
    if (i < 0 || i >= list->len) // 越界检查
    {
        printf("寻找错误\n");
        return NULL;
    }

    ListNode* current = list->head;

    for (int j = 0; j < i; j++) // 遍历到第i个节点
    {
        current = current->next;
    }
    return current;
}

// 更新链表元素
void Update_LInked(LinkedList* list, int i, int value)
{
    ListNode* temp = Find_Index_Linked(list, i);

    if (temp) // 如果节点存在
    {
        temp->data = value; // 更新数据
    }
}

// 打印链表
void Print_Linked(LinkedList* list)
{
    ListNode* current = list->head;

    while (current)
    {
        printf("%d <-> ", current->data); // 打印当前节点
        current = current->next; // 移动到下一个节点
    }
    printf("NULL\n");
}

int main()
{
    LinkedList list; // 定义链表

    Creat_LinkedList(&list); // 创建链表

    Insert_LinkList(&list, 0, 10); // 插入数据
    Insert_LinkList(&list, 1, 20);
    Insert_LinkList(&list, 2, 30);
    Insert_LinkList(&list, 3, 40);

    printf("Original List:\n");
    Print_Linked(&list); // 打印链表

    Delete_LinkList(&list, 2); // 删除节点
    Update_LInked(&list, 1, 100); // 更新数据
    printf("Change1 List:\n");
    Print_Linked(&list); // 打印链表

    ListNode* found = Find_element_Linked(&list, 30); // 查找元素

    if (!found)
    {
        printf("此节点不存在\n");
    }

    Destroy_LinkList(&list); // 销毁链表
    system("pause");
    return 0;
}

  纯私人撰写，欢迎大家私信勘误！！

Erik_LinX
关注
简单易懂的C语言实现双向链表代码
我不是萧海哇的博客
06-17 295
#include <stdio.h> #include <string.h> #include <stdlib.h> //节点结构体，每个节点分别保存了一个指向前一个节点的指针和指向后一个节点的指针，以及保存数据的指针 struct _node{ struct _node *prevNode; struct _node *nextNode; void *data; }; //链表结构体，记录了链表的首节点和尾节点指针，以及节点总个数
C语言笔试经典之双向链表的实现
STL1634614466的博客
01-03 8113
C语言笔试经典之双向链表的实现1、节点定义typedef struct DListElement_ { void * data; struct DListElement_ *prev; struct DListElement_ *next; }DListElement;2、链表定义typedef struct DList_ { int size; DListE
04.线性表.链式存储结构（双向循环链表）
hyde100的专栏
07-15 749
以下是用双向循环链表实现的线性表 #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType;//ElemType这里假设为int，可以根据需要进行更改 typedef int Status;//Status是函数的类型,其值是函数
数据结构-双向链表（C语言）
usiehheu的博客
05-03 1850
文章目录1、双向链表的定义2、双向链表的初始化3、双向链表的打印4、双向链表的插入5、双向链表的删除6、双向链表的元素定位7、链表清空8、测试二、完整代码 1、双向链表的定义 双向链表是链表的一种，与单链表不同的shi，它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。 typedef struct DoubleLinkNode { char data; struct DoubleLink
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中的第一个数据元素 10.将游标移动指向到链表中的下一个数据元素 11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
链表基本操作伪代码
weixin_47500703的博客
03-13 3099
文章目录链式结构体头插法创建尾插法求表长按值查找按位查找插入删除按值删除(first)按值删除(all)有序表的合并循环链表双向链表静态链表 链式结构体 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; } LNode, *LinkList; //声明变量 LinkList L; 头插法创建 Initial(LinkList &L) { L = (LinkList
将两个链表（可为乱序）合并成一个有序链表（C语言实现）
weixin_50080319的博客
11-07 4106
谭浩强c语言第五版第9章的习题10，本文主题如下： 1.对参考答案代码进行解析和勘误； 2.提出一种更准确的算法，给出代码；
C语言链表无锁化CAS,无锁双链表的原子操作
weixin_35940587的博客
05-24 553
我根据这些文件编写了无锁双向链表：“基于引用计数的高效可靠的无锁内存回收”，Anders Gidenstam，成员，IEEE，Marina Papatriantafilou，H˚akan Sundell和Philippas Tsigas“无锁双端队列和双链表”，Philippas Tsigas，HåkanSundell对于这个问题，我们可以搁置第一篇论文。在本文中，他们使用一种聪明的方式在单词中存...
C语言双向链表详解：结构与实现实例
以下是一段C语言的双向链表基础操作的代码示例： 1. 定义双向链表节点结构体，包含数据类型data，以及指向前一个节点（prior）和后一个节点（next）的指针： ```c typedef struct DuLNode { ElemType data; ...
c语言编程题之链表操作删除链表中的节点.zip
03-30
链表分为单向链表和双向链表，这里我们主要讨论的是单向链表。 要删除链表中的节点，我们需要知道要删除节点的位置。通常有两种情况：删除特定值的节点和删除指定位置的节点。 1. 删除特定值的节点： 这种方法需要...
数据结构之双向链表（C语言实现）
kang___xi的博客
11-26 9662
数据结构之双向链表（C语言实现）
数据结构之C语言实现双向链表
煮酒论英雄
07-07 7876
C语言实现双向链表 双向链表主要实现以下功能： 双向链表创建 节点头插 节点尾插 指定位置插入节点 节点删除 链表排序 链表求长 /****************************************************************************************************** * function：自定义一个...
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2735
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
C语言双向链表实现
lichangshun3的博客
09-10 1772
C语言双向链表实现 链表是计算机编程中常用的一种数据结构，在大部分面向对象的编程语言中都会有封装好的类供用户直接使用，只有在数据结构课程中，老师才会要求学生用代码实现一个链表，而如果用C语言实现链表，除了要了解链表的特性之外，对于指针的操作也是一个重头戏。 开发环境：VS2013 开发系统：window7 头文件（TwoWayList.h）代码如下： #ifndef TWOWAY_...
C语言算法基础——双向链表的实现代码
weixin_52109967的博客
07-22 760
菜鸟日常学习算法的总结！
MT1421-MT1430 码题集 (c 语言详解)
最新发布
赔罪的博客
11-04 462
给定一个由N(
通用型函数——冒泡排序
2401_84654619的博客
10-29 540
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值