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

已于 2023-08-08 11:36:39 修改
阅读量207 收藏 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 9722
题目描述1.问题描述给出初始数据，实现单链表的定义、创建、查找和删除。假设单链表中的结点计数从1开始。2.算法单链表结点的存储结构包含两部分：数据、下一结点指针。单链表的创建：依次为输入的数据分配结点，并按序链接起来。单链表的查找：给出位置i，若第i个结点存在(1&lt;=i&lt;=表中结点数L)，返回结点地址；否则，返回NULL。单链表的删除：给出位置i，删除第i个结点(1&lt;=i&lt;...
带头结点的双向循环链表的增删查改
WangLongxyd的博客
05-17 377
双向循环链表
线性表技巧之Note005-删除链表节点
二木成林
04-06 1469
线性表技巧之Note005-删除链表节点
[数据结构-4] 循环链表
xiaoyouyouaaa的博客
03-05 2159
详细讲解循环链表基本概念, 算法复杂度, 以及使用C语言实现
数据结构-带头循环双向链表
m0_61245168的博客
09-28 258
学习了简单的单链表，我们继续学习结构稍复杂但有巨大优势的带头循环双向链表。
数据结构-链表（C语言+动态内存管理）
weixin_72501602的博客
05-08 666
无哨兵位单链表
双向带头循环链表（增删查改）
weixin_70056514的博客
03-14 652
大家有没有发现上一期的单链表结构在尾插和中间插入的时候会使用得非常的难受呢？中间插入需要额外定义一个指针保存插入位置的前一个位置的地址，尾插又需要从头开始一直找到最后才能找到尾部再插入，归根到底都是因为单链表不能往回找上一个结点，所以今天给大家分享一个结构设计得更好的链表：双向带头循环链表。双向链表，顾名思义就是既能往后找下一个结点，又能往前找上一个结点的链表，那么需要怎么设计这个结构呢？其实很简单，只需要在结点的结构体里面多加一个指向前一个结点的指针就行了。下面我们就来逐步地实现这个双向链表。
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别
输出分享
04-08 1248
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别，简单易懂，轻松掌握。
双链表的增删查改实现（c语言描述）
未见花闻的博客
07-12 622
内容导读 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、带头+双向+循环链表增删查改实现// ...
【数据结构】带头节点的双向循环链表基本操作
风铃的博客
12-06 332
目的 实现双向循环带头节点的链表的增删改查 创建返回链表头节点 // 创建返回链表的头结点. ListNode* ListCreate() { ListNode *head = (ListNode*)malloc(sizeof(ListNode)); head->next = head; head->prev = head; return head; } 双向链表的销毁 // 双向链表销毁 void ListDestory(ListNode* pHead) { assert(pH
双端链表list的实现 | 自己实现Redis源代码(2)
qq_40955287的博客
03-07 143
通过对《Redis设计与实现》一书的学习，我打算动手自己实现一份“Redis源代码”作为自己的学习记录。 对Redis感兴趣的同学可以查看我的另一篇文章 造个轮子 | 自己动手写一个Redis。 本章介绍的是Redis源代码中的双端链表list的实现。 双端链表list的实现 list的API （1）创建一个不包含任何结点的新链表 list *listCreate(void); （2）释放给定...
【leetcode】单链表题集
xiaoshe的专栏
05-13 300
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 320
不知道各位有没有看过一部国漫——《刺客伍六七》。在我这个血统并不算纯的二次元来说，这部动漫无论从剧情还是打斗等各个方面，都可以算的上是动漫中的一流作品了。/*仅仅在我看过的动漫中*/ 当然这篇博客的主题肯定不是来讲动漫的。我们今天的主题正如标题所言，是数据结构的一大地基——链表。在我的见闻中，链表此物，与刺客伍六七中主角阿柒的“专武”——神锻国国宝——魔刀千刃，有着异曲同工之妙。与普通的刀剑（顺序表）不同，魔刀千刃（链表）由一片片碎片组成，可以随主人的心意作为一个整体的刀或分解为一个个碎片来进攻敌人，号称
数据结构之[双链表的是实现]【保姆级讲解】
cls的博客
10-23 492
上篇文章我们实现了链表中两大重要链表之一无头单项非循环链表，这次我们来实现带头双向循环链表。 话不多说上图： 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向 循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而 简单了，后面我们代码实现了就知道了。 废话不多说我们进入正题： 进行带头双向循环链表的实现 根据上图我们可以看出，该链表需要存储两个指针，所以我们在定义的时候就需要一前一后俩指...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 382
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 326
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1101
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1163
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值