数据结构——带头双向循环链表（c语言实现）

最新推荐文章于 2024-08-06 21:51:46 发布
最新推荐文章于 2024-08-06 21:51:46 发布
阅读量2.7k 收藏 74
点赞数 104
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 c语言 循环链表 双向链表 开发语言 动态内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58761784/article/details/139993531
版权

目录

 

1.单链表和双向链表对比

2.双向链表实现

2.1 创建新节点

2.2 链表初始化 

2.3 尾插 

2.4 头插 

2.5 尾删 

2.6 头删 

2.7 查找 

2.8 指定位置后插入数据 

2.9 删除指定节点 

2.10 销毁链表

2.11 打印链表 

 前言：

     我们在前几期详细地讲解了不带头单向不循环链表（单链表），使用它的底层代码实现了一个简单的通讯录项目，也介绍了链表分为八种，但是其中最常用的只有两种：（1）不带头单向不循环链表，（2）带头双向循环链表，今天我们要讲解的就是第二种带头双向循环链表

1.单链表和双向链表对比

在介绍双向链表之前，我们先来对比一下单链表和双向链表的区别。

这是单链表：

这是双向链表：

 

        双向链表的特点是每相邻两个节点都相互连接，每个节点都有三个部分，包括data，next，prev，其中data负责存放数据，next负责存放后一个节点的地址，prev负责存放前一个节点的地址，最后一个节点和头节点（哨兵位）相互连接，形成了一个循环双向链表，那么什么是哨兵位呢，哨兵位就是双向链表的头节点，它不存放有效数据，只存放第一个有序数据的节点的地址和最后一个有序数据节点的地址。 

       那么它们的区别是什么呢？

1. 无头单向非循环链表： 结构简单 ，一般不会单独用来存数据。实际中更多是作为 其他数据结构的子结 构 ，如哈希桶、图的邻接表等等。另外这种结构在 笔试面试 中出现很多。
2. 带头双向循环链表： 结构最复杂 ，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而 简单了，后面我们代码实现了就知道了。

2.双向链表实现

  介绍完了双向链表的区别我们接下来就要着手开始用代码实现双向链表了。由于代码可能较多，我们将双向链表的代码分成了三个文件，分别是List.h,List.c和tste.c文件：

在list.h文件中，我们要包含我们会用到的头文件，其他文件只要包含List.h文件就可以使用这些头文件了：

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

双向链表的实现也是在此文件中，由于我们不知道将来使用链表会存放什么样的数据，所以我们使用typedef对这个数据的类型改名，我们实现链表使用的是int类型，所以我们对int改名：

typedef int ListNodeData;

链表中的next和prev链表是用来存放节点地址的，所以它们为指针类型，而为了方便使用，我们将链表使用typedf改名，下面是双向链表实现：

typedef struct ListNode
{
	ListNodeData data;
	struct ListNode* prev;
	struct ListNode* next;

}LTNode;

2.1 创建新节点

创建新节点我们使用malloc从堆申请一块LTNode类型大小的内存，它的data类型用来存放将来要插入的数据，prev和next指针在创建这个节点时先让它指向自己，如果要创建新节点，就调用这个函数，它会返回一个指向这块空间的指针：

LTNode* LTBuyNode(ListNodeData x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode;
	newnode->prev = newnode;

	return newnode;

}//创建一个新节点

2.2 链表初始化 

 

在最初创建一个链表时，它的内部为空，什么也没有，我们初始化应该此链表让它至少有一个哨兵位：

void LTInit(LTNode** pphead)
{
	assert(pphead);
	*pphead = LTBuyNode(-1);


}//初始化

2.3 尾插 

尾插操作应该先创建一个新节点，插入顺序为：先让新节点的prev指针指向最后一个节点，然后让新节点的next指针指向哨兵位实现循环，以上的两步都不会影响旧节点，接下来就是让最后一个节点的next指针指向这个新节点，然后让哨兵位的prev指针指向新节点完成尾插：

具体实现代码为：

void LTPushBack(LTNode* phead, ListNodeData x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead;
	newnode->prev = phead->prev;

	phead->prev->next = newnode;
	phead->prev = newnode;
}//尾插

2.4 头插 

     头插操作并不是将新节点放在哨兵位之前，而是将新节点放在第一个有效数据节点之前，所以我们应该将新节点放在哨兵位的后面。先创建一个新节点，让新节点的prev指针指向哨兵位，让它的next指针指向哨兵位的next指向的节点，以上两步不会影响任何节点，做完这两步后，先让哨兵位后面那个节点的prev指针指向新节点，然后让哨兵位的next指针指向新节点，这两步不能调换顺序，否则会找不到哨兵位后面那个节点，下面是代码实现：

void LTPushFront(LTNode* phead, ListNodeData x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;

}//头插

2.5 尾删 

   执行删除操作之前我们应该先判断这个链表除哨兵位之外有没有其他节点，如果没有，就无法删除，而尾删操作也比较简单，只需要让尾节点的前一个节点的next指针指向哨兵位，然后让哨兵位的prev指针指向位尾节点，以上过程需要创建一个新变量，否则无法找到我们要删除的节点，接着释放掉尾节点后置空就可以了：

void LTPopBack(LTNode* phead)
{
	assert(phead&&phead->next);
	LTNode* del = phead->prev;

	del->prev->next = del->next;
	del->next->prev = del->prev;
	free(del);
	del = NULL;

}//尾删

画图演示：

 

2.6 头删 

  头删操作与尾删类似，如果没有两个及以上节点的话无法执行删除操作，头删要删除的是哨兵位后面那个节点，所以我们先创建一个指针存放我们要删除节点的地址，将哨兵位的next指针指向我们要删除节点的下一个节点，然后将我们要删除节点的下一个节点的prev指针指向哨兵位，完成这些操作后释放我们要删除的节点然后置空：

void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next);
	LTNode* del = phead->next;

	phead->next = del->next;
	del->next->prev = phead;
	free(del);
	del = NULL;
}//头删

2.7 查找 

如果我们要查找一个节点，应该先判断链表是否为空，然后将我们要查找的节点的数据与链表中节点的数据一一对比，如果数据内容相同，说明找到了，将这个节点返回，如果循环一圈还没有找到，说明链表中不存在这样的节点，返回应一个空指针：

LTNode* LTFind(LTNode* phead, ListNodeData x)
{
	assert(phead && phead->next);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}//查找函数

2.8 指定位置后插入数据 

我们可以先调用查找函数，然后调用它返回的节点，试着在它的后面插入数据，而它的操作与头插非常相像，只是将哨兵位改成了我们指定的节点：

void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x)
{
	assert(phead&&pop);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pop;
	newnode->next = pop->next;

	pop->next->prev = newnode;
	pop->next = newnode;
}//指定节点后插入数据

2.9 删除指定节点 

删除节点我们需要先判断链表中是否有两个及以上节点，否则无法删除，删除指定节操作我们先将指定节点的前一个节点的next指向我们指定节点的下一个节点，然后将指定节点的下一个节点的prev指针指向指定节点的前一个节点，这个过程不需要创建中间变量，因为我们有指定节点的地址：

void LTErase(LTNode* phead, LTNode* pop)
{
	assert(phead && phead->next);
	pop->next->prev = pop->prev;
	pop->prev->next = pop->next;

	free(pop);
	pop = NULL;

}//指定删除节点

2.10 销毁链表

我们链表的每一个节点都是使用malloc函数手动在堆上申请的，需要我们手动释放：

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}

}//销毁链表

2.11 打印链表 

指行这么多插入删除操作我们如果测试的话就使用这个函数打印出来，而打印函数只需要循环打印这个链表一次就可以了：

void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");

}//打印

接下来我们使用这个函数来测试一下我们的方法：

可以看到我们的方法都没有问题，那么这期的双向链表就到此结束啦，我将代码放在下面，感兴趣的小伙伴可以试试哦。

List.h :

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

typedef int ListNodeData;
typedef struct ListNode
{
	ListNodeData data;
	struct ListNode* prev;
	struct ListNode* next;

}LTNode;




LTNode* LTFind(LTNode* phead, ListNodeData x);//查找

void LTInit(LTNode** pphead);//初始化

void LTPushBack(LTNode* phead, ListNodeData x);
//尾插

void LTPrint(LTNode* phead);//打印链表

void LTPushFront(LTNode* phead, ListNodeData x);
//头插

void LTPopBack(LTNode* phead);//尾删

void LTPopFront(LTNode* phead);//头删

void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x);
//指定节点后删除

void LTErase(LTNode* phead, LTNode* pop);
//指定位置删除

void LTDestroy(LTNode* phead);
//销毁链表

List.c :

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"

LTNode* LTBuyNode(ListNodeData x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode;
	newnode->prev = newnode;

	return newnode;

}//创建一个新节点

LTNode* LTFind(LTNode* phead, ListNodeData x)
{
	assert(phead && phead->next);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}//查找函数

void LTInit(LTNode** pphead)
{
	assert(pphead);
	*pphead = LTBuyNode(-1);


}//初始化

void LTPushBack(LTNode* phead, ListNodeData x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead;
	newnode->prev = phead->prev;

	phead->prev->next = newnode;
	phead->prev = newnode;
}//尾插

void LTPushFront(LTNode* phead, ListNodeData x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;

}//头插

void LTPopBack(LTNode* phead)
{
	assert(phead&&phead->next);
	LTNode* del = phead->prev;

	del->prev->next = del->next;
	del->next->prev = del->prev;
	free(del);
	del = NULL;

}//尾删

void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next);
	LTNode* del = phead->next;

	phead->next = del->next;
	del->next->prev = phead;
	free(del);
	del = NULL;
}//头删

void LTInsertAfter(LTNode* phead, LTNode* pop, ListNodeData x)
{
	assert(phead&&pop);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pop;
	newnode->next = pop->next;

	pop->next->prev = newnode;
	pop->next = newnode;
}//指定节点后插入数据

void LTErase(LTNode* phead, LTNode* pop)
{
	assert(phead && phead->next);
	pop->next->prev = pop->prev;
	pop->prev->next = pop->next;

	free(pop);
	pop = NULL;

}//指定删除节点




void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");

}//打印

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}

}//销毁链表

test.c :

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void test01()
{
	LTNode* plist = NULL;
    LTInit(&plist);
	printf("尾插\n");
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);
	printf("头插\n");
	LTPushFront(plist, 0);
	LTPrint(plist);

	/*printf("尾删\n");
	LTPopBack(plist);
	LTPopBack(plist);
	LTPrint(plist);*/
	printf("头删\n");
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);

	printf("在3后面插入数据:\n");
	LTNode* Find = LTFind(plist, 3);
	/*if (Find == NULL)
	{
		printf("找不到！\n");
	}
	else
	{
		printf("找到了\n");
	}*/
	LTInsertAfter(plist, Find, 56);
		LTPrint(plist);

		printf("删除指定节点3：\n");
		LTErase(plist, Find);
		LTPrint(plist);
		printf("销毁链表\n");
		LTDestroy(plist);
		plist = NULL;
		
		





}

int main()
{
	test01();
	return 0;
}

 

 

 

 

 

 

 

 

 

 

 

 

不穿格子衬衫
关注
  • 104
    点赞
  • 踩
  • 74
    收藏
    觉得还不错? 一键收藏
  • 55
    评论
专栏目录
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的...总的来说，这篇文档详细介绍了如何使用C语言实现双向循环链表的初始化、插入、删除和查找操作，对于理解链表数据结构以及在C语言中操作链表有很好的指导作用。
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构——顺序表
脑壳有点痒，好像要长脑子了！
08-03 954
顺序表是数据结构中的一种重要形式，它属于线性表的一种顺序存储结构，其逻辑上相邻的元素在物理存储位置上也相邻。用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
最新发布
weixin_44399845的博客
08-06 488
学习下词条的排解冲突方法
数据结构 二叉树和堆总结
gma999的博客
07-31 1063
二叉树和堆的总结
【数据结构】堆的实现
t5y22的博客
08-03 575
堆
初识集合和数据结构
m0_51821434的博客
08-03 855
这次文章就浅浅的介绍了一下数据结构的基础知识，集合的框架，算法的一些特性
探索哈希表：C++中的实现与操作详解【Map、Set、数据结构】
qq_22841387的博客
08-03 773
哈希表（Hash Table）是一种常见的数据结构，它提供了一种高效的键值对存储方式，能够快速进行插入、删除和查找操作。在这篇博客中，我们将详细介绍哈希表的概念、在C++中的实现方式以及常见操作的示例。哈希表是一种通过哈希函数将键映射到存储桶（Bucket）或槽（Slot）中的数据结构。其核心思想是使用哈希函数将键转换为数组的索引，从而能够在常数时间内（平均情况下）进行查找、插入和删除操作。哈希表是一种高效的数据结构，广泛应用于需要快速查找、插入和删除操作的场景中。在C++中，提供了便捷的哈希表实现。
数据结构2:C++基于二叉堆实现优先队列
LorraineWen的博客
08-03 573
C++通过二叉堆实现优先队列
数据结构----------贪心算法
yuanbenshidiaos的博客
08-05 1750
贪心算法（Greedy Algorithm）是一种在问题求解过程中，每一步都采取当前状态下最优（即最有利）的选择，从而希望导致最终的全局最优解的算法策略。贪心算法的核心思想是做选择时，每一步只考虑当前情况的最佳选择，不考虑整体情况，也不考虑这个选择将如何影响未来的选择。局部最优选择：在每一步选择中都采取当前状态下最优的选择。不可回溯：一旦做出了选择，就不可撤销，也就是选择了某一部分的解之后，就不再考虑这个选择之前的其他可能性。最优子结构。
【数据结构之单链表的实现（不带头）】
2302_79546368的博客
08-03 778
与顺序表不同的是，链表里面的每节“车厢”都是独立申请下来的空间，所以我们之为“节/结点”。因此为了便于操作其它数据类型的操作，我们对类型进行重命名。假设当前链表中保存的是整型数据，当然我们也可以保存其它。保存下一个节点的地址（指针变量）当前节点要保存的数据。
数据结构：顺序表
2401_86551514的博客
08-01 1063
顺序表是线性表的一种，而线性表是n个具有相同特性的数据元素的有限序列，线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的⼀条直线，但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储，这个物理结构是否连续就是看物理地址上是否连续。顺序表与数组的区别：顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接⼝。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出，如果喜欢的话，
【数据结构】链表篇
2303_79015671的博客
08-03 1379
手把手教你实现链表~
2024年华为OD机试真题-二叉树的广度优先遍历-Java-OD统一考试（C卷）
面试高手的博客
08-06 160
现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请输出层次遍历的结果。- 在后序遍历中，最后一个元素总是树的根节点。- 在中序遍历中，根节点的位置可以将序列分为两部分，左边部分为左子树，右边部分为右子树。- 通过在中序遍历中查找后序遍历的最后一个元素（根节点）来确定左右子树。- 特点：根节点总是在遍历序列的最后位置，可以用来确定树的根。- 访问顺序：左子树 -> 根节点 -> 右子树。- 访问顺序：左子树 -> 右子树 -> 根节点。
【C语言篇】操作符详解（下篇）
2301_79849925的博客
08-03 815
操作符详解（下篇）操作符的优先级，结合性是如何的呢，整型提升和算术转换时怎么样进行的呢，一起来看看吧！
c语言11天笔记
m0_74916669的博客
08-06 609
我们在函数设计过程中，经常要考虑对参数的设计，换句话说，我们需要考虑函数需要几个参数，需 要什么类型的参数，但我并没有考虑函数是否需要提供参数，如果说函数可以访问到已定义的数据， 则就不需要提供函数形参，那么我么到底要不要提供函数参数，取决于什么？原因是数组形参代 表的仅仅是实际数组的首地址。外部函数：使用extern修饰的函数，称作外部函数，extern是默认的，可以不写，也就是说本质上 我们所写的函数都是外部函数，建议外部函数在被其他文件调用的时候，在其他文件中声明的时 候，加上extern关键字。
C语言基础题：吃冰棍（C语言版）
我就知道你会来，我们一起进步吧！
08-04 1362
所以，如果机器猫买了5根冰棍，他可以吃完之后得到5个木棒;拿3个木棒兑换1根冰棍，余2个木棒;吃完兑换来的冰棍之后，手上有3个木棒，又能兑换一个冰棍。最后，机器猫实际上吃了7个冰棍。买一根冰棍，吃完了会剩一个木棒;每三个木棒可以兑换一个冰棍。兑换出来的冰棍，吃完之后也能剩下一个木棒。机器猫想要吃到 几 个冰棍，想问最开始至少需要去买多少根冰棍?对于 100% 的数据，1
评论 55
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值