【数据结构】带头循环双链表的增删查改

已于 2023-08-08 11:36:39 修改
阅读量224 收藏 9
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 算法 经验分享
于 2023-08-06 23:09:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hamdh/article/details/132135517
版权

引言：

双链表是一种常用的数据结构，它可以在O(1)的时间复杂度下实现插入、删除和查找操作。双链表中的每个节点都包含一个指向前一个节点和后一个节点的指针，这样可以方便地在任意位置进行插入和删除操作。

在本篇博客中，我们将介绍带头循环双链表的实现，并给出相应的代码示例。

代码实现

首先，我们需要定义一个节点结构体，包含数据和指向前后节点的指针。使新创建的节点存储数据x，前后指针制空。

//创建节点
ListNode* BuyListNode(LTDataType x) {
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL) {
		perror("fail malloc");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

接下来，我们需要实现一些基本的操作。

       1.1.创建链表：创建一个带头节点的空链表。
// 创建返回链表的头结点.
ListNode* ListCreate() {
	ListNode* head = BuyListNode(0);
	head->data = NULL;
	head->next = head;
	head->prev = head;
}
        1.2.销毁链表：释放链表中的所有节点。
// 双向链表销毁
void ListDestory(ListNode* pHead) {
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur) {
		pHead->next = cur->next;
		cur->next->prev = cur->prev;
		free(cur);
		cur = cur->next;
	}
}
         1.3.打印链表：按顺序打印链表中的所有节点。
// 双向链表打印
void ListPrint(ListNode* pHead) {
	assert(pHead);
	printf("head<->");
	ListNode* cur = pHead->next;
	while (cur != pHead) {
		printf("%d<->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

 完成一些基础操作后，接下来就是关于双链表的增删改查

        2.1. 尾插节点：在链表的末尾插入一个新节点。原理如图所示：

               思路：创建一个名为newnode的节点，将它的前指针指向尾节点tail，后指针指向头节点head，而head的前指针、tail的后指针指向newnode，如此便形成了尾插操作。代码的基本逻辑就是这样。

                 来看代码：

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	ListNode* tail = pHead->next;
	while (tail->next != pHead) {
		tail = tail->next;
	}
	newnode->next = pHead;
	newnode->prev = tail;
	tail->next = newnode;
	pHead->prev = newnode;

	//复用
	//ListInsert(pHead, x);
}

        

         2.2.尾删节点：删除链表的末尾节点。原理如图所示：

               思路：将原本指向tail的指针指向tail的前一个节点，再将其借助free函数释放掉。

                来看代码：

// 双向链表尾删
void ListPopBack(ListNode* pHead) {
	assert(pHead);
	assert(pHead->next != pHead);
	ListNode* tail = pHead->next;
	while (tail->next!=pHead) {
		tail = tail->next;
	}
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	//复用
	//ListErase(pHead->prev);
}

        2.3. 头插节点：在链表的头部插入一个新节点。原理如图所示：

               原理： 创建一个名为newnode的节点，将它的前指针指向头节点head，后指针指向下一个节点，而head的后指针、下一个节点的前指针指向newnode，如此便形成了前插操作。代码的基本逻辑就是这样。

               来看代码 ：

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x) {
	assert(pHead);

	ListNode* newnode = BuyListNode(x);
	newnode->prev = pHead;
	newnode->next = pHead->next;
	pHead->next = newnode;
	pHead->prev->prev = newnode;

	//复用
	//ListInsert(pHead->next, x);
}

           2.4. 头删节点：删除链表的头部节点。

                  原理： 将head的后指针指向下下的节点，下下个节点的前指针指向head借助free函数释放原本头指针后节点指向的节点。

                    来看代码 ：

// 双向链表头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);
	
	ListNode* pNext = pHead->next;
	pHead->next = pNext->next;
	pNext->next->prev = pNext->prev;
	free(pNext);
	//复用
	//ListErase(pHead->next);
}

然后我们来看怎么实现查找、删除及插入 ：

            3.1.查找节点：在链表中查找特定的节点。

                  根据输入的数值x，我们创建一个指针pos，遍历一遍链表，就能确定链表里面的值有没有x了。这里大家需要注意：这是一个循环链表，要怎么实现只遍历一遍呢？这里就需要一个条件了，就是pos的下一个不等于头节点。遍历一遍，如果找得到，返回节点；找不到，返回false。

                  来看代码：

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {
	assert(pHead);
	assert(pHead->next != NULL);

	ListNode* pos = pHead->next;
	while (pos->next!=pHead) {
		if (pos->data == x) {
			return pos;
		}
        pos=pos->next;
	}
	return false;
}
                3.2.在指定位置插入节点：在链表中的指定位置插入一个新节点。

                      原理：创建一个新节点newnode，标记指定位置的前一个节点为nPrev，nPrev的后指针、指定节点的前指针指向newnode，newnode的前指针指向nPrev，后指针指向指定位置的节点。可以在前面函数中复用。

                      来看代码：

// 双向链表在pos位置进行插入
void ListInsert(ListNode* pos, LTDataType x) {
	assert(pos);
	ListNode* newnode = BuyListNode(x);
	ListNode* nPrev;
	nPrev = pos->prev;

	newnode->prev = nPrev;
	newnode->next = pos;

}
                  3.3. 删除指定位置的节点：删除链表中的指定位置的节点。

                         原理：将指定位置的前节点和后节点标记，让前节点的后指针指向后节点，后节点的前指针指向前节点，再借助free函数释放指定位置的节点即可。可以在前面函数中复用。

                         来看代码：

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos) {
	assert(pos);
	ListNode* posPrev,* posNext;
	posPrev = pos->prev;
	posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

 完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;
//创建节点
ListNode* BuyListNode(LTDataType x) {
	ListNode* node = (ListNode*)malloc(sizeof(ListNode*));
	if (node == NULL) {
		perror("fail malloc");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

// 创建返回链表的头结点.
ListNode* ListCreate() {
	ListNode* head = BuyListNode(0);
	head->data = NULL;
	head->next = head;
	head->prev = head;
}
// 双向链表销毁
void ListDestory(ListNode* pHead) {
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur) {
		pHead->next = cur->next;
		cur->next->prev = cur->prev;
		free(cur);
		cur = cur->next;
	}
}
// 双向链表打印
void ListPrint(ListNode* pHead) {
	assert(pHead);
	printf("head<->");
	ListNode* cur = pHead->next;
	while (cur != pHead) {
		printf("%d<->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	ListNode* tail = pHead->next;
	while (tail->next != pHead) {
		tail = tail->next;
	}
	newnode->next = pHead;
	newnode->prev = tail;
	tail->next = newnode;
	pHead->prev = newnode;

	//复用
	//ListInsert(pHead, x);
}
// 双向链表尾删
void ListPopBack(ListNode* pHead) {
	assert(pHead);
	assert(pHead->next != pHead);
	ListNode* tail = pHead->next;
	while (tail->next!=pHead) {
		tail = tail->next;
	}
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	//复用
	//ListErase(pHead->prev);
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x) {
	assert(pHead);

	ListNode* newnode = BuyListNode(x);
	newnode->prev = pHead;
	newnode->next = pHead->next;
	pHead->next = newnode;
	pHead->prev->prev = newnode;

	//复用
	//ListInsert(pHead->next, x);
}
// 双向链表头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);
	
	ListNode* pNext = pHead->next;
	pHead->next = pNext->next;
	pNext->next->prev = pNext->prev;
	free(pNext);
	//复用
	ListErase(pHead->next);
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x) {
	assert(pHead);
	assert(pHead->next != NULL);

	ListNode* pos = pHead->next;
	while (pos->next!=pHead) {
		if (pos->data == x) {
			return pos;
		}
	}
	return false;
}
// 双向链表在pos位置进行插入
void ListInsert(ListNode* pos, LTDataType x) {
	assert(pos);
	ListNode* newnode = BuyListNode(x);
	ListNode* nPrev;
	nPrev = pos->prev;

	newnode->prev = nPrev;
	newnode->next = pos;

}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos) {
	assert(pos);
	ListNode* posPrev,* posNext;
	posPrev = pos->prev;
	posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

 总结：

                以上就是双链表的实现代码和相关操作的说明。双链表具有灵活性和高效性，适用于需要频繁插入和删除操作的场景。希望本篇博客对你理解双链表的实现有所帮助。如果有任何疑问或建议，请留言讨论。谢谢！

游是水里的游
关注
专栏目录
单链表（带头结点）的删除
zzzzhdx的博客
03-10 9761
题目描述1.问题描述给出初始数据，实现单链表的定义、创建、查找和删除。假设单链表中的结点计数从1开始。2.算法单链表结点的存储结构包含两部分：数据、下一结点指针。单链表的创建：依次为输入的数据分配结点，并按序链接起来。单链表的查找：给出位置i，若第i个结点存在(1&lt;=i&lt;=表中结点数L)，返回结点地址；否则，返回NULL。单链表的删除：给出位置i，删除第i个结点(1&lt;=i&lt;...
带头结点的双向循环链表的增删查改
WangLongxyd的博客
05-17 398
双向循环链表
线性表技巧之Note005-删除链表节点
二木成林
04-06 1549
线性表技巧之Note005-删除链表节点
[数据结构-4] 循环链表
xiaoyouyouaaa的博客
03-05 2177
详细讲解循环链表基本概念, 算法复杂度, 以及使用C语言实现
数据结构-带头循环双向链表
m0_61245168的博客
09-28 268
学习了简单的单链表，我们继续学习结构稍复杂但有巨大优势的带头循环双向链表。
数据结构-链表（C语言+动态内存管理）
weixin_72501602的博客
05-08 681
无哨兵位单链表
双向带头循环链表（增删查改）
weixin_70056514的博客
03-14 682
大家有没有发现上一期的单链表结构在尾插和中间插入的时候会使用得非常的难受呢？中间插入需要额外定义一个指针保存插入位置的前一个位置的地址，尾插又需要从头开始一直找到最后才能找到尾部再插入，归根到底都是因为单链表不能往回找上一个结点，所以今天给大家分享一个结构设计得更好的链表：双向带头循环链表。双向链表，顾名思义就是既能往后找下一个结点，又能往前找上一个结点的链表，那么需要怎么设计这个结构呢？其实很简单，只需要在结点的结构体里面多加一个指向前一个结点的指针就行了。下面我们就来逐步地实现这个双向链表。
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别
记录这一刻。
04-08 1263
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别，简单易懂，轻松掌握。
双链表的增删查改实现（c语言描述）
未见花闻的博客
07-12 629
内容导读 1.什么是双链表 1.1 双链表概述 1.2循环链表 1.3双链表的优点 2.双链表的定义以及常见功能的实现 2.0双链表定义以及常见功能头文件 2.1双链表定义（声明） 2.2双链表内存申请及扩容 2.3双链表初始化 2.4双链表的打印 2.5双链表的插入与删除操作理论 2.6双链表头插操作代码实现 2.7双链表尾插操作代码实现 2.8双链表的位置pos（已知）前插入操作代码实现 2.9双链表的头删操作代码实现 2.10双链表尾删操作代码实现 2.11双...
链表数据结构详解与增删查改实现教程
资源摘要信息:"数据结构顺序表和链表（超详细）" ...理解链表的增删查改操作对于掌握数据结构与算法的实现至关重要。通过文件中提及的压缩包中的实践代码，可以加深对链表操作的理解，并在实际开发中灵活应用。
数据结构顺序表和链表（超详细）
08-14
动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的值//销毁2、带头+双向+循环链表增删查改实现// ...
双端链表list的实现 | 自己实现Redis源代码(2)
qq_40955287的博客
03-07 149
通过对《Redis设计与实现》一书的学习，我打算动手自己实现一份“Redis源代码”作为自己的学习记录。 对Redis感兴趣的同学可以查看我的另一篇文章 造个轮子 | 自己动手写一个Redis。 本章介绍的是Redis源代码中的双端链表list的实现。 双端链表list的实现 list的API （1）创建一个不包含任何结点的新链表 list *listCreate(void); （2）释放给定...
【leetcode】单链表题集
xiaoshe的专栏
05-13 322
1，反转单链表 来源：206. 反转链表 &&剑指 Offer 24. 反转链表 迭代思路：采用头插法创建一个新的单链表。时间复杂度O(N)，空间复杂度O(1)。 class Solution { public: ListNode* reverseList(ListNode* head) { ListNode *result = NULL; while (head) { ListNode *next = head-...
真正的入门——链表
qq_56713382的博客
12-01 327
不知道各位有没有看过一部国漫——《刺客伍六七》。在我这个血统并不算纯的二次元来说，这部动漫无论从剧情还是打斗等各个方面，都可以算的上是动漫中的一流作品了。/*仅仅在我看过的动漫中*/ 当然这篇博客的主题肯定不是来讲动漫的。我们今天的主题正如标题所言，是数据结构的一大地基——链表。在我的见闻中，链表此物，与刺客伍六七中主角阿柒的“专武”——神锻国国宝——魔刀千刃，有着异曲同工之妙。与普通的刀剑（顺序表）不同，魔刀千刃（链表）由一片片碎片组成，可以随主人的心意作为一个整体的刀或分解为一个个碎片来进攻敌人，号称
Redis的数据结构
2302_81083129的博客
10-31 1005
缓存穿透、缓存雪崩、缓存击穿、Redis的数据结构及常用命令
【数据结构与算法】第7课—数据结构之队列
weixin_70620792的博客
10-31 445
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表栈只允许在栈顶进行插入数据删除数据的操作，称为入栈、出栈（或压栈）队列则是队尾进队头出，满足先进先出的原则，而栈则是后进先出。
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 334
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
[数据结构]堆
2401_83816455的博客
10-29 288
堆，本质是一颗完全二叉树。代码实现可参考树的代码。
数据结构之顺序表（C语言）
最新发布
Duan1044592637的博客
11-01 871
1 线性表介绍 2 顺序表的分类 3 顺序表的初始化、打印与销毁 4 顺序表的尾插法与头插法 5 顺序表的尾删和头删 6 指定位置的插入与删除 7 顺序表数据查找 8 顺序表全程序及演示结果
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值