C/C++数据结构——双链表

已于 2022-11-21 08:59:56 修改
阅读量642 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-11-17 22:01:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63883017/article/details/127873604
版权

文章目录

前言

该篇文章是继上一篇文章数据结构之单链表如果没有看过前一篇文章建议先把那篇文章看了再看这里，不然可能看不懂，还有就是，上一篇说的单向不带头节点，所以我在上一篇提到的头节点指的是第一个节点***，而我在***这篇文章中提到的所有头节点都是指的标兵位（也有叫哨兵位的），和上一篇中说的不是一个东西，希望大家别搞混了。
数据结构——单链表

单向不带头非循环的优缺点

优点：

不需要向顺序表一样，频繁扩容，而且不会浪费空间，不管是头插还是中间插入,特别方面，不需要移动元素，直接插入即可

缺点：

在尾插的时候需要遍历链表，找到最后一个节点才能插入，这就使得尾插效率比较低

通过单链表的不足引入双向带头循环链表

在这里插入图片描述

对于单向链表，尾插效率低，在这里引入带头循环链表，头节点存放两个指针，一个指针指向第一个节点，一个指针指向最后一个节点，这样便形成一个环，想找到最后一个节点只需要一行代码，这样大大的提高了尾插的效率

双向带头循环链表的实现

节点定义

typedef int anytype;

typedef struct STL_list{
	anytype data;
	struct STL_list* prev;		//用于指向前一个节点
	struct STL_list* next;		//用于指向后一个节点
}list;

链表初始化

因为这是带头的链表，所以在还没有任何数据插入时这个头节点就要创建好，要插入数据就往这个头节点后面插，就算清空整个链表也不能删除这个头节点，只有在销毁这个链表的时候才能把这个头节点删除
又因为这是一个双向循环链表，所以头节点的prev指针要指向最后一个节点，最后一个节点的next指针要指向头节点，当链表为空的时候，头节点还拥有其他两个身份，他既是第一个节点又是最后一个节点，所以初始化的时候我们让头节点的next和prev都指向自己
在这里插入图片描述

list* List_Init() {			//链表初始化成功返回指向头节点的指针
	list* plist = (list*)malloc(sizeof(list));
	if (plist != NULL) {
		plist->data = 0;	//头节点的data可以不使用他，也可以使用他记录一些特殊标志位什么的
		plist->next = plist;
		plist->prev = plist;
	}
	return plist;
}

main掉用示例

#<include>
typedef struct STL_list{
	anytype data;
	struct STL_list* prev;		//用于指向前一个节点
	struct STL_list* next;		//用于指向后一个节点
}list;

int main(){
	list* phead = List_Init(); 
	/*调用初始化链表的函数，接收指向头节点的指针,初始化完成，链表就创建
	成功了，只是目前链表为空，拿到头节点的指针之后可以做任何想做的事了，头插，尾插，头删，尾删等等*/
	push_front(phead,1);
	push_front(phead,2);
	push_front(phead,3);
	return 0;
}

创建节点

不管在任何位置插入节点都要先申请节点，有节点才能插入，所以为了提高代码的复用和减少代码量，我们把创建节点单独封装成一个函数

list* Add_newspace(anytype x) {
	list* newspace = (list*)malloc(sizeof(list));
	if (newspace != NULL) {
		newspace->data = x;
		newspace->next = NULL;
		newspace->prev = NULL;
		return newspace;
	}
	return NULL;
}

打印链表

因为在初始化的时候我们就让链表的头节点的prev和next节点指向自己了，所以判断这个链表是否为空只需要判断头节点的prev和next指针是不是指向自己就可以了，如果链表不为空，循环打印，为空直接返回

void list_printf(list* phead) {
	list* cur = phead->next;
	if (phead->next == phead) {
		printf("链表为空！\n");
		return;
	}
	else {
		while (cur != phead)
		{
			printf("%d ", cur->data);
			cur = cur->next;
		}
		printf("\n");
	}
}

尾插节点

示意图
在这里插入图片描述
尾插原理：我们要找到最后一个节点，插入流程分五步
在这里不用考虑当链表为空的情况，因为我们在初始化的时候就让头节点（哨兵位）的prev和next指针都指向了自己，已经形成了一个循环，当链表为空时，头节点不仅只是哨兵位，同时也是第一个节点，又是最后一个节点
如果不明白在纸上画一画就明白了，学数据结构一定要多画！
1.找到最后一个节点保存到cur
2.让最后一个节点的next指针指向即将插入的新节点
3.让新节点的prev指针指向链表的最后一个节点
4.让头节点（哨兵位）的prev指针指向新节点
5.让新节点的next指针指向头节点（哨兵位）

void push_back(list* phead, anytype x) {
	list* newspace = Add_newspace(x); 	//创建节点
    list* cur = phead->prev;			//得到最后一个节点对应第一步
	cur->next = newspace;				//对应插入流程第二步
	newspace->prev = cur;				//对应插入流程第三步
	phead->prev = newspace;				//对应插入流程第四步
	newspace->next = phead;				//对应插入流程第五步
}

头插节点

在这里插入图片描述
头插原理：要先找到第一个节点，当然这个非常简单，头节点的next指针指向的就是第一个节点，这里同上，不用考虑链表为空的情况
流程分五步：
第一：找到第一个节点，保存到cur中
第二：先让第一个节点指向新节点
第三：再让新节点的prev指针指向头节点
第四：让新节点的next指针指向第一个节点
第五：让第一个节点的prev指向新节点

void push_front(list* phead, anytype x) {
	list* newspace = Add_newspace(x);
	list* cur = phead->next;
	phead->next = newspace;
	newspace->prev = phead;
	newspace->next = cur;
	cur->prev = newspace;
}

尾删节点

在这里插入图片描述
尾删原理：先用头节点的prev指针找到最后一个节点，再通过最后一个节点找到最后一个节点的前一个节点，然后把最后一个节点的前一个节点与头节点连接起来即可，大致分为以下几步：
1: 找到尾节点并保存起来（这里我保存到了cur中）
2.判断链表是否为空，如果链表为空直接退出
3.把尾节点的前一个节点保存起来（这里我保存到了prev中）
4.让最后一个的前一个节点的next指针指向头节点
5.让头节点的prev指针指向最后一个节点的前一个节点
6.删除最后一个节点

//以下步骤依次对应上面6步
void pop_back(list* phead) {
	list* cur = phead->prev;
	if (cur == phead) {				
		printf("链表为空！");
		return;						
	}
	else {
		list* prev = cur->prev;
		prev->next = phead;
		phead->prev = prev;
		free(cur);
		cur = NULL;
	}
}

头删节点

头删和尾删原理一样，只是这里我们找到的是第一个节点和第一个节点后面的那个节点，然后把头节点和第一个节点后面的那个节点连接起来，最后把头节点删除即可，如果不理解可以再倒回去看看尾删

void pop_front(list* phead) {
	list* cur = phead->next;
	if (cur == phead){
		printf("链表为空！");
		return;
	}
	else {
		list* next = cur->next;
		phead->next = next;
		next->prev = phead;
		free(cur);
		cur = NULL;
	}
}

查找指定节点

原理：找到了就返回指定节点的指针，找不到就返回空
老规矩还是要先判断链表是否为空，如果是空直接返回，否则就循环对比，找到指定节点直接返回该节点指针，若链表不为空，循环也没找到，说明该节点不存在，返回空

list* find(list* phead, anytype x) {
	list* cur = phead->next;
	if (cur == phead) {				//判断链表是否为空
		return NULL;
	}
	else {
		while (cur != phead) {			//循环对比
			if (cur->data == x) {
				return cur;				//找到了立即退出
			}
			cur = cur->next;
		}
	}
	return NULL;				//链表不为空，循环也没找到，返回NULL
}

在指定节点的下一个位置添加节点

重点： 调用这个函数之前一定要先调用上面那个find函数，再把find函数的返回值传到这个函数中
原理：要添加新节点第一步先申请空间，存放节点
然后判断传进来的指针是否为空，如果为空直接返回
然后找到指定节点的下一个节点，把这个新节点放到这两个节点中间连接起来即可
（若看不懂代码，可以倒回去看看头插）

void Insert(list* pos, anytype x) {
	list* newspace = Add_newspace(x);		
	if (pos == NULL) {			//判断传进来的指针是否有效
		printf("pos为空！\n");
	}
	else {						//插入新节点
		list* cur = pos->next;		
		pos->next = newspace;
		newspace->prev = pos;
		newspace->next = cur;
		cur->prev = newspace;
	}
}

删除指定节点

和上面一样，先用find函数找到你要删的函数，然后再把find函数的返回值传进来，然后找到这个节点的前一个和后一个节点，把他的前一个和后一个节点连接，最后再把这个节点删除掉，别忘了把指针置空，否则可能出现野指针

void Erase(list* pos) {
	if (pos == NULL) {
		printf("pos为空！\n");		//判断传进来的指针是否有效
	}
	else {							//连接要删除节点的前一个节点和后一个节点，再删除该节点
		list* next = pos->next;
		list* prev = pos->prev;
		next->prev = prev;
		prev->next = next;
		free(pos);
		pos = NULL;
	}
}

销毁链表

这个就比较简单粗暴了，循环从最后一个节点删，一直到把头节点都删掉为止

void Destroy(list ** phead) {
	while (*phead != NULL) {	//只要指向头节点的指针没有被置空说明链表还在，要继续删		
		list* cur = (*phead)->next;	//找到最后一个节点
		if (cur == *phead) {		/*如果最后一个节点就是头节点，说明链表为空了，把头节点删除，
指向头节点的指针置空，该函数执行完毕*/                             
			(*phead)->next = NULL;
			(*phead)->prev = NULL;
			free((*phead));
			(*phead) = NULL;
		}
		else {	//链表不为空，删除最后一个节点
			list* next = cur->next;
			(*phead)->next = next;
			next->prev = (*phead);
			free(cur);
			cur = NULL;
		}
	}
}

完整代码

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

typedef int anytype;

typedef struct STL_list {
	anytype data;
	struct STL_list* prev;
	struct STL_list* next;
}list;

list* List_Init();
void list_printf(list* phead);
list* Add_newspace(anytype x);
void push_back(list* phead, anytype x);
void push_front(list* phead, anytype x);
void pop_back(list* phead);
void pop_front(list* phead);
list* find(list* phead, anytype x);
void Insert(list* pos, anytype x);
void Erase(list* pos);
void Destroy(list** phead);


list* List_Init() {
	list* plist = (list*)malloc(sizeof(list));
	if (plist != NULL) {
		plist->next = plist;
		plist->prev = plist;
	}
	return plist;
}
void list_printf(list* phead) {
	list* cur = phead->next;
	if (phead->next == phead) {
		printf("链表为空！\n");
		return;
	}
	else {
		while (cur != phead)
		{
			printf("%d ", cur->data);
			cur = cur->next;
		}
		printf("\n");
	}
}
list* Add_newspace(anytype x) {
	list* newspace = (list*)malloc(sizeof(list));
	if (newspace != NULL) {
		newspace->data = x;
		newspace->next = NULL;
		newspace->prev = NULL;
		return newspace;
	}
	return NULL;
}
void push_back(list* phead, anytype x) {
	list* newspace = Add_newspace(x);
	list* cur = phead->prev;
	newspace->prev = cur;
	cur->next = newspace;
	newspace->next = phead;
	phead->prev = newspace;
}
void push_front(list* phead, anytype x) {
	list* newspace = Add_newspace(x);
	list* cur = phead->next;
	phead->next = newspace;
	newspace->prev = phead;
	newspace->next = cur;
	cur->prev = newspace;
}
void pop_back(list* phead) {
	list* cur = phead->prev;
	if (cur == phead) {
		printf("链表为空！");
		return;
	}
	else {
		list* prev = cur->prev;
		prev->next = phead;
		phead->prev = prev;
		free(cur);
		cur = NULL;
	}
}
void pop_front(list* phead) {
	list* cur = phead->next;
	if (cur == phead) {
		printf("链表为空！");
		return;
	}
	else {
		list* next = cur->next;
		phead->next = next;
		next->prev = phead;
		free(cur);
		cur = NULL;
	}
}
list* find(list* phead, anytype x) {
	list* cur = phead->next;
	if (cur == phead) {
		return NULL;
	}
	else {
		while (cur != phead) {
			if (cur->data == x) {
				return cur;
			}
			cur = cur->next;
		}
	}
	return NULL;
}
void Insert(list* pos, anytype x) {
	list* newspace = Add_newspace(x);
	if (pos == NULL) {
		printf("pos为空！\n");
	}
	else {
		list* cur = pos->next;
		pos->next = newspace;
		newspace->prev = pos;
		newspace->next = cur;
		cur->prev = newspace;
	}
}
void Erase(list* pos) {
	if (pos == NULL) {
		printf("pos为空！\n");
	}
	else {
		list* next = pos->next;
		list* prev = pos->prev;
		next->prev = prev;
		prev->next = next;
		free(pos);
		pos = NULL;
	}
}
void Destroy(list** phead) {
	while (*phead != NULL) {
		list* cur = (*phead)->next;
		if (cur == *phead) {
			(*phead)->next = NULL;
			(*phead)->prev = NULL;
			free((*phead));
			(*phead) = NULL;
		}
		else {
			list* next = cur->next;
			(*phead)->next = next;
			next->prev = (*phead);
			free(cur);
			cur = NULL;
		}
	}
}
int main()
{
	list* phead = List_Init();
	for (int i = 0; i < 10; i++) {
		push_back(phead,i);
	}
	list_printf(phead);
	return 0;
}

总结

到这里链表就差不多干完了，我主要讲了单向不循环不带头和双向循环带头，只要把这两种弄明白了，剩下的单向循环，单向带头，双向不循环，双向不带头等，就不是什么大问题了，相信家人们肯定能自己弄出来。
最后再申明一下，虽然我一直在拿各种数据结构做对比，但是并不是说那一种最好，我这样做只是为了方便记忆，还是那句话，没有最好的，只有最合适的，要根据实际场景选择合适的数据结构。

徐个愿望~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构C++版的双循环链表
07-06
在IT领域，数据结构是计算机科学的基础，...总的来说，这个项目提供了学习和实践C++中数据结构——双循环链表的好机会。通过这个实践，你可以深化对C++面向对象编程的理解，同时增强在实际问题中应用数据结构的能力。
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
【C++学习笔记】数据结构与算法——设计双链表
最新发布
qq_58517981的博客
09-10 69
head为虚拟头结点，head->next为第一个头结点。
【C++STL】双向循环链表与其迭代器的深度剖析及实现（百字短文速通）
qq_73216106的博客
02-08 1598
初学者学习笔记
【C++】双向链表
Sunny的博客
03-05 1153
逆序建立一个双向链表，该链表从第二个结点至表尾递增有序，将第一个结点删除并插入到适当位置，使整个链表仍然递增有序。
【C++实现双链表】
wddkxg的博客
03-02 191
学习双链表的结构、头插法建表、尾插法建表以及双链表的操作实现。 C++实现双链表
双向循环链表（C++实现）
st66688的博客
09-22 2785
双向循环链表内容整理
Array.rar_数据结构_C/C++_
08-11
在本案例中，我们关注的是“Array.rar”压缩包，它专注于C/C++编程语言中的一个核心数据结构——链表。链表是一种线性数据结构，不同于数组，它的元素在内存中不是顺序存放的，而是通过指针链接。 链表的主要优点...
hashk.rar_数据结构_C/C++__数据结构_C/C++_
08-09
C/C++语言由于其高效性和灵活性，常常被用来实现各种数据结构。本压缩包文件“hashk.rar”专注于一个特定的数据结构应用——字符串哈希函数的实现。 哈希函数是一种在数据结构中广泛使用的工具，它能够将任意长度的...
数据结构单双链表c++版
07-14
在这个"数据结构单双链表C++版"的压缩包中，我们主要关注的是两种基本的数据结构——单链表和双链表，它们在C++编程环境下被实现。这两种链表都是线性数据结构的实例，是数组的延伸，特别适用于处理动态变化大小的...
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
双向链表结构
10-26
基于C语言的双向链表,对于C语言初学者具有很好的帮助,可以加深对双向链表的理解
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
双链表C++实现范例
08-16
C++写的实现双链表功能， 简单易懂带有详细注释等等 欢迎下载
C/C++链表速通! 超细图解！多图警告!每一行代码都有相应图解释保证能学会
LT_Sakurakaze的博客
12-28 496
这个链表教程可以分为《C++ 外部实现》《C语言外部实现》《C++class内实现》《head在函数全局变量》《head在局部变量》《使用场景》
链表的基本操作(C/C++)
热门推荐
风间琉璃的博客
10-13 1万+
文章目录前言一、单链表定义二、单链表的基本操作1.遍历操作2.链表长度3.链表查找4.链表插入5.头插入法(创建链表)6.尾插法(创建链表)7.删除结点8.链表释放三、循环链表四、双向链表总结 前言 提示：以下是本篇文章正文内容 一、单链表定义 当需要建立一个学生信息表,学生的人数无法确定而且人数经常变化,此时若用顺序表来实现将会很麻烦 单链表:线性表的链接存储结构, 用一组任意(不联系, 零散分布) 的存储单元存放线性表的元素. 存储特点: 1.逻辑次序和物理次序不一定相同 2.元素之..
【数据结构】链表定义及其常用的基本操作（C/C++）
EWEADN
12-10 3068
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
C++双向链表
vv的博客
05-05 336
本文C++实现的关于双向链表的增删查改操作，收获颇多，第一篇博客请多指教。 定义节点类型 struct Number{ int data; Number* next; Number* previous; }; 定义一个链表类 class LinkList{ private: Number *head; Number *tail; int...
C/C++ 链表（单链表）
qq_37082966的博客
05-27 2149
（1）了解链表 链表是线性表的一种。 线性表有两种存储结构： 1、顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素； 2、链式存储结构（链表）：是由一系列连接在一起的结点构成，其中的每个结点都是一个数据结构 （2）链表的结构： 先介绍链表的结构成分： 1、结点 结点有两部分信息组成，一部分是数据域：用来存放数据元素信息；另一种用来存放地址的域称为指针域，指针域中存储的信息称作指针或链。我们把结点记为Node。 2、头结点： （1）：头结点是为了操作的统一与方便而设立的，放在第一个元素结点之
【最新编排】宿舍管理系统 链表 C语言 C++ 数据结构 链表 课程设计.doc
06-18
【最新编排】宿舍管理系统 链表 C语言 C++ 数据结构 链表 课程设计

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

徐个愿望~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值