【数据结构】速速收藏，一文带你参透双向链表各接口实现_使用双向链表实现数据接收的方法(1)

已于 2024-05-06 22:25:24 修改
阅读量505 收藏 6
点赞数 26
分类专栏： 程序员 文章标签： 数据结构 链表
于 2024-05-06 22:25:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84166236/article/details/138510585
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

void LPopBack(LNode* phead)
{
    if ((phead == NULL) || (phead->next == phead))    //排除为空的情况
    {
        return;
    }
    LNode* tail = phead->prev;    //找到尾
    LNode* tailprev = tail->prev;    //找到尾的前驱
    tailprev->next = phead;    //尾前驱节点的后继指针指向头
    phead->prev = tail->prev;  //头的前驱指针指向尾的前驱
    free(tail);
    tail = NULL;
}
  • 测试尾删接口功能实现：

Ⅵ.双向链表头插：
  • 在执行操作前应当对传入指针进行判断，防止传入空指针。
  • 在改变指向前，应当首先保存哨兵节点的后继节点，因为当我们插入新节点后链表结构将会发生改变，再想要找到该节点将变得麻烦。
  • 进行插入操作时，使哨兵节点的后继指针指向新节点，再使新节点的前驱指针指向哨兵节点，接着使用同样的操作使新节点与哨兵节点的原后继节点互指。
void LPushFront(LNode* phead, LDataType x)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* newnode = BuyListNode(x);
    LNode* next = phead->next;    //保存哨兵节点的后继节点
    phead->next = newnode;    //哨兵点的后继指针指向新节点
    newnode->prev = phead;    //新节点的前驱指针指向哨兵节点
    newnode->next = next;    //新节点的后继指针指向哨兵节点的原后继节点
    next->prev = newnode;    //哨兵节点的原后继节点前驱指针指向新节点
}
  • 测试头插接口功能实现：

Ⅶ.双向链表头删：
  • 首先**进行非空判断，并排除链表为空（只含有哨兵节点）**的情况。
  • 开始进行头删操作前找到并保存头节点，防止改变指向后链表结构发生变化难以找到原本的头节点，以便于最后进行释放。
  • 并且应当找到并保存原头节点的后继节点，防止防止改变指向后链表结构发生变化而难以找到。
  • 具体操作便是使哨兵节点与头节点的后继节点跳过头节点互指，再将要删除的头节点释放并置空即可。
void LPopFront(LNode* phead)
{
    if ((phead == NULL) || (phead->next == phead))    //排除为空的情况
    {
        return;
    }
    LNode* next = phead->next;    //保存头节点，便于释放
    LNode* nextNext = next->next;    //保存头节点的后继节点
    phead->next = nextNext;
    nextNext->prev = phead;
    free(next);
    next = NULL;
}
  • 测试头删接口功能实现：

Ⅷ.双向链表查找：
  • 执行操作前需进行非空判断，防止对空指针进行操作。
  • 查找逻辑很简单，遍历整个链表，直至链表完整循环一遍，若比对存在匹配元素返回该节点，否则返回空。
LNode* LFind(LNode* phead, LDataType x)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* cur = phead->next;
    while (cur != phead)
    {
        if (cur->data == x)
        {
            return cur;
        }
        else
        {
            cur = cur->next;
        }
    }
    return NULL;
}
  • 测试查找接口功能实现：

Ⅸ.双向链表给定节点前插：
  • 执行操作前需进行非空判断，防止对空指针进行操作。
  • 执行逻辑很简单，将数据存入通过动态申请的来的新节点中后，找到目标节点，使目标节点的前驱节点与新节点互指，再使新节点与目标节点互指接即可。
void LInsert(LNode* pos, LDataType x)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->prev;
    LNode* newnode = BuyListNode(x);
    posPrev->next = newnode;
    newnode->prev = posPrev;
    newnode->next = pos;
    pos->prev = newnode;
}
  • 测试前插接口功能实现：

Ⅹ.双向链表给定节点后插：
  • 执行操作前需进行非空判断，防止对空指针进行操作。
  • 执行逻辑与前插高度类似，不同的是使目标节点的后继节点与新节点互指，再使新节点与目标节点互指。
void LInsertBack(LNode* pos, LDataType x)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->next;
    LNode* newnode = BuyListNode(x);
    posPrev->prev = newnode;
    newnode->next = posPrev;
    newnode->prev = pos;
    pos->next = newnode;
}
  • 测试后插接口功能实现：

ⅩⅠ.双向链表删除给定节点：
  • 执行操作前需进行非空判断，防止操作空指针。
void LErase(LNode* pos)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->prev;
    LNode* posNext = pos->next;
    posPrev->next = posNext;
    posNext->prev = posPrev;
    free(pos);
    pos = NULL;
}
  • 测试删除接口功能实现：

ⅩⅡ.双向链表销毁：
  • 若哨兵节点为空，即表示链表内没有有效数据节点，则无需进行销毁、释放与置空操作。
  • 含有有效节点则遍历所有节点，将每一个节点均进行释放，特别注意所有数据节点释放完毕之后，不要忘记释放哨兵节点。
void LDestroy(LNode* phead)
{
    if(phead==NULL)
    {
        return;
    }
    LNode* cur = phead->next;
    while (cur != phead);
    {
        LNode* next = cur->next;
        free(cur);
        cur = next;
    }
    free(phead);
    phead = NULL;
}

🍄三、完整接口实现代码🍄：

1.List.h：

#pragma once

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

//自定数据类型LDataType：
typedef int LDataType;

//双向链表节点结构：
typedef struct ListNode
{
	LDataType data;
	struct LNode* next;
	struct LNode* prev;
}LNode;

LNode* LInit();    //初始化双向循环链表
void LPrint(LNode* phead);    //打印双向循环链表
LNode* BuyListNode(LDataType x);//双向循环链表新节点申请
void LPushBack(LNode* phead, LDataType x);    //双向循环链表尾插
void LPopBack(LNode* phead);    //双向循环链表尾删
void LPushFront(LNode* phead, LDataType x);    //双向循环链表头插
void LPopFront(LNode* phead);    //双向循环链表头删
LNode* LFind(LNode* phead, LDataType x);    //双向循环链表查找
void LInsertFront(LNode* pos, LDataType x);    //双向循环链表给定节点前插
void LInsertBack(LNode* pos, LDataType x);    //双向循环链表给定节点后插
void LErase(LNode* pos);    //双向循环链表给定节点删除
void LDestroy(LNode* phead);    //双向循环链表的销毁

2.List.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

//初始化双向循环链表初始化：
LNode* LInit()
{
	//哨兵位头节点：
	LNode* phead = (LNode*)malloc(sizeof(LNode));
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

//打印双向循环链表
void LPrint(LNode* phead)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* cur = phead->next;
    while (cur != phead)
    {
        printf("%d -> ", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

//双向循环链表申请新节点：
LNode* BuyListNode(LDataType x)
{
    LNode* newnode = (LNode*)malloc(sizeof(LNode));
    newnode->data = x;
    newnode->next = NULL;
    newnode->prev = NULL;
    return newnode;
}

//双向循环链表尾插：
void LPushBack(LNode* phead, LDataType x)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* tail = phead->prev;    //找到尾节点
    LNode* newnode = BuyListNode(x);
    //新尾互指：
    tail->next = newnode;
    newnode->prev = tail;
    //新头互指：
    phead->prev = newnode;
    newnode->next = phead;
}

//双向循环链表尾删：
void LPopBack(LNode* phead)
{
    if ((phead == NULL) || (phead->next == phead))    //排除为空的情况
    {
        return;
    }
    LNode* tail = phead->prev;    //找到尾
    LNode* tailprev = tail->prev;    //找到尾的前驱
    tailprev->next = phead;    //尾前驱节点的后继指针指向头
    phead->prev = tail->prev;  //头的前驱指针指向尾的前驱
    free(tail);
    tail = NULL;
}

//双向循环链表头插：
void LPushFront(LNode* phead, LDataType x)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* newnode = BuyListNode(x);
    LNode* next = phead->next;    //保存哨兵节点的后继节点
    phead->next = newnode;    //哨兵点的后继指针指向新节点
    newnode->prev = phead;    //新节点的前驱指针指向哨兵节点
    newnode->next = next;    //新节点的后继指针指向哨兵节点的原后继节点
    next->prev = newnode;    //哨兵节点的原后继节点前驱指针指向新节点
}

//双向循环链表头删：
void LPopFront(LNode* phead)
{
    if ((phead == NULL) || (phead->next == phead))    //排除为空的情况
    {
        return;
    }
    LNode* next = phead->next;    //保存头节点，便于释放
    LNode* nextNext = next->next;    //保存头节点的后继节点
    phead->next = nextNext;
    nextNext->prev = phead;
    free(next);
    next = NULL;
}

//双向循环链表查找：
LNode* LFind(LNode* phead, LDataType x)
{
    if (phead == NULL)
    {
        return;
    }
    LNode* cur = phead->next;
    while (cur != phead)
    {
        if (cur->data == x)
        {
            return cur;
        }
        else
        {
            cur = cur->next;
        }
    }
    return NULL;
}

//双向循环链表给定节点前插：
void LInsert(LNode* pos, LDataType x)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->prev;
    LNode* newnode = BuyListNode(x);
    posPrev->next = newnode;
    newnode->prev = posPrev;
    newnode->next = pos;
    pos->prev = newnode;
}

//双向循环链表给定节点前插：
void LInsertFront(LNode* pos, LDataType x)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->prev;
    LNode* newnode = BuyListNode(x);
    posPrev->next = newnode;
    newnode->prev = posPrev;
    newnode->next = pos;
    pos->prev = newnode;
}

//双向循环链表给定节点后插：
void LInsertBack(LNode* pos, LDataType x)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->next;
    LNode* newnode = BuyListNode(x);
    posPrev->prev = newnode;
    newnode->next = posPrev;
    newnode->prev = pos;
    pos->next = newnode;
}

//双向循环链表给定节点删除：
void LErase(LNode* pos)
{
    if (pos == NULL)
    {
        return;
    }
    LNode* posPrev = pos->prev;
    LNode* posNext = pos->next;
    posPrev->next = posNext;
    posNext->prev = posPrev;
    free(pos);
    pos = NULL;
}

//双向循环链表销毁：
void LDestroy(LNode* phead)
{
    if(phead==NULL)
    {
        return;
    }
    LNode* cur = phead->next;
    while (cur != phead);
    {
        LNode* next = cur->next;
        free(cur);
        cur = next;
    }
    free(phead);
    phead = NULL;
}

3.test.c：

#define _CRT_SECURE_NO_WARNINGS 1

#include"List.h"

void LTest()
{
	LNode* plist = LInit();
	//双向循环链表尾插：
	LPushBack(plist, 1);
	LPushBack(plist, 2);
	LPushBack(plist, 3);
	LPushBack(plist, 4);
	LPrint(plist);    //打印链表
	LNode* ret = LFind(plist, 3);
	LErase(ret);
	LPrint(plist);    //打印链表
}

int main()
{
	LTest();

	return 0;
}

//双向循环链表尾插与尾删：
//LNode* plist = LInit();
双向循环链表尾插：
//LPushBack(plist, 1);
//LPushBack(plist, 2);
//LPushBack(plist, 3);
//LPushBack(plist, 4);
//LPrint(plist);    //打印链表
双向循环链表尾删：
//LPopBack(plist);
//LPopBack(plist);
//LPopBack(plist);
//LPrint(plist);    //打印链表

//双向循环链表头插与头删：
//LNode* plist = LInit();
//双向循环链表头插：
//LPushFront(plist, 1);
//LPushFront(plist, 2);
//LPushFront(plist, 3);
//LPushFront(plist, 4);
//LPrint(plist);    //打印链表
双向循环链表头删：
//LPopFront(plist);
//LPopFront(plist);
//LPopFront(plist);
//LPrint(plist);    //打印链表

//双向循环链表查找：
//LNode* plist = LInit();
//双向循环链表尾插：
//LPushBack(plist, 1);
//LPushBack(plist, 2);
//LPushBack(plist, 3);
//LPushBack(plist, 4);
//LPrint(plist);    //打印链表
//LNode* ret = LFind(plist, 3);

//双向循环链表给定位置前插：
//LNode* plist = LInit();
双向循环链表尾插：
//LPushBack(plist, 1);
//LPushBack(plist, 2);
//LPushBack(plist, 3);
//LPushBack(plist, 4);
//LPrint(plist);    //打印链表


![img](https://img-blog.csdnimg.cn/img_convert/1373927d5bcab1a69d4c6da79ca1d020.png)
![img](https://img-blog.csdnimg.cn/img_convert/a02561634d3caefc56724ec3fd6cc8e4.png)
![img](https://img-blog.csdnimg.cn/img_convert/f0436fc51930506da21a30e1e2be5d3e.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

ack(plist, 3);
//LPushBack(plist, 4);
//LPrint(plist);    //打印链表
//LNode* ret = LFind(plist, 3);

//双向循环链表给定位置前插：
//LNode* plist = LInit();
双向循环链表尾插：
//LPushBack(plist, 1);
//LPushBack(plist, 2);
//LPushBack(plist, 3);
//LPushBack(plist, 4);
//LPrint(plist);    //打印链表


[外链图片转存中...(img-5bwTiXDD-1715005506986)]
[外链图片转存中...(img-y9ojwGQO-1715005506986)]
[外链图片转存中...(img-8ixsDlBW-1715005506987)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**
2401_84166236
关注
  • 26
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一文参透并发编程，阿里大牛两万字总结 +40 张图文详解
l688899886的博客
06-21 241
分布式模型的思想就是借鉴并发模型的基础上推演发展来的。并发模型的一个重要的方面是，线程是否应该共享状态，是具有共享状态还是独立状态。共享状态也就意味着在不同线程之间共享某些状态状态其实就是数据，比如一个或者多个对象。当线程要共享数据时，就会造成竞态条件或者死锁等问题。当然，这些问题只是可能会出现，具体实现方式取决于你是否安全的使用和访问共享对象。独立的状态表明状态不会在多个线程之间共享，如果线程之间需要通信的话，他们可以访问不可变的对象来实现，这是最有效的避免并发问题的一种方式，如下图所示使用独立状态让我们
链表-使用PHP实现的双向链表数据结构.zip
03-13
链表 链表_使用PHP实现的双向链表数据结构
【数据结构】速速收藏，一文带你参透双向链表各接口实现_使用双向链表实现数据接收的方法
2401_84183628的博客
05-11 906
这其中，我们的接口实现主要研究的是。
【数据结构】速速收藏，一文带你参透双向链表各接口实现
weixin_59392935的博客
01-18 2411
上节课中我们完整的实现了无头单向链表的各个功能接口，但是我们也注意到，由于单向链表只保存指向下一节点的指针，于是我们在进行前插等操作时，还需要遍历链表来找到前一个节点，效率不高且步骤繁琐。于是为了克服类似这样的问题，我们更多的会使用另一种数据结构，即带头双向循环链表，本文就将带领各位小伙伴们一起实现带头双向循环链表的各接口功能。
一文参透并发编程，阿里资深架构师两万字总结 +40 张图文详解
weixin_49307478的博客
09-09 210
从输出的结果就可以看到，任务都是挨着执行的。我为任务分配了五个线程，但是这五个线程不像是我们之前看到的有换进换出的效果，它每次都会先执行完自己的那个线程，然后余下的线程继续走完这条线程的执行路径。由于线程的本质，使你不能捕获从线程中逃逸的异常，一旦异常逃出任务的 run 方法，它就会向外传播到控制台，除非你采取特殊的步骤捕获这种错误的异常，在 Java5 之前，你可以通过线程组来捕获，但是在 Java 5 之后，就需要用 Executor 来解决问题，因为线程组不是一次好的尝试。
告诉你一个 AtomicInteger 的惊天大秘密！
陈树义
05-10 402
我们在 Java 并发基础知识一文中说到2w字 + 40张图带你参透并发编程！i++ 不是线程安全的操作，因为它不是一个原子性操作。那么，如果我想要达到类似 i++ 的这种效果，我应该使用...
Java多线程导论及延申
pukka的博客
03-16 1677
并发大全 JUC大全 2万字参透并发编程 jvm中线程分为哪些状态 在执行Thread.start()方法后，线程是不是马上运行。 多线程导论 原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 有序性即程序执行的顺序按照代码的先后顺序执行。 多线程设计模式解读—Producer-Consumer模式 请简述一下线程的sleep()方法和yi.
JAVA学习文档220507
u013707288的博客
05-07 461
Java基础核心串讲 计算机操作系统与Linux Java基础面试16问 52图初探Linux通用知识 学习linux命令，看这篇2w多字的命令详解就够了 图解HTTP协议 一文领略 HTTP 的前世今生 面试 HTTP ，99% 的面试官都爱问这些问题 实战！敖丙用“大白鲨”让你看见 TCP 面试官：换人！他连 TCP 这几个参数都不懂 TCP/IP..
敖冰目录123
renxanshou的博客
04-16 923
我会从下图中的知识点去写这个系列，很多细节的点，可能想得不是很完善，大家可以去【公众号】获取或者加我【微信】提意见(别忘记Star哟)。 原创文章每周最少两篇，公众号首发文章，【B站】首发视频，比博客早一到两篇。 后端面试点合集 脑图在线编辑地址 目录(善用Ctrl+F) 注 : 没链接的是还没写(耐心等待更新吧) 学习路线 后端技术学些啥 从毕业到技术专家我做了啥 秒杀系统设计 全栈
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
数据结构的链表关系，用TC2.0 编写，比较完整，可以作为学生的教学用
tongxunlu.rar_C语言双向链表_city_doubly linked list_tongxunlu_数据结构 通讯录
09-22
用〈〈数据结构〉〉中的双向链表作数据结构，结合C语言基本知识。编写一个通讯录管理系统。以把所学数据结构知识应用到实际软件开发中去。 设计内容：本系统应完成一下几方面的功能： 输入信息——enter() 显示信息...
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
tushuguan.cpp.rar_C语言双向链表_数据结构 管理_数据结构 管理系统_链表图书馆
09-21
一个用C语言编写的图书馆管理系统，采用双向链表的数据结构。基本功能都已具备
10种排序算法总结-（c语言实现与动画演示）
qq_37040743的博客
05-29 480
十种常见排序算法可以分为：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破，因此也称为非线性时间比较类排序。：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
二叉树的顺序结构及实现（堆的实现）
最新发布
2301_81154519的博客
05-30 1041
介绍了堆并且用代码去实现堆
【初阶数据结构】栈和队列（附题目）
2401_82610555的博客
05-30 1086
栈的初始化中，需要注意的是_top的初始值初始化为-1与初始化为0是截然不同的。我们知道，head是指向队列的头，tail指向尾的下一位，因为我们多开了一个空间，并且是按序的空出空间，因此，当数组满时，尾的空间后面就是空空间，tail指向它，这时如果tail再向前走一步，就与head相等，不过这时，为了避免出现越界的情况，tail+1需要%（K+1），这就相当于tail+1>5时，tail+1-5，tail回到数组开头，同时数组越界的情况是相对与数组总长的，因此这里是%（k+1）不是%k.
【数据结构】二叉树的实现
小八哥
05-30 1163
关于二叉树，你真的了解的吗？
数据结构—栈（C语言实现）
wu_geng_liu_li的博客
05-27 1043
小伙伴们，大家好哇！！欢迎来到我的博客！今天来分享一下另外一种数据结构—栈。主要包括栈的基本概念与其代码实现，最后使用该数据结构巧妙地解决一道算法题。以上就是有关栈这一数据结构的问题分享，如果觉得对你有帮助的话，希望小伙伴们可以点点“栈”（赞）！！
实现不带头结点的双向循环链表的创建，实现该双向循环链表上数据的排序数据结构代码
03-12
以下是实现不带头结点的双向循环链表的创建以及排序的数据结构代码： ```c++ #include using namespace std; struct Node { int data; Node* prev; Node* next; }; Node* createList(int arr[], int n) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值