【初阶数据结构】双向链表

最新推荐文章于 2025-03-25 00:08:04 发布
最新推荐文章于 2025-03-25 00:08:04 发布
阅读量960 收藏 9
点赞数 27
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2503_90450246/article/details/145530926
版权

前面的文章有介绍过顺序表与单向链表

  1. 顺序表
  2. 单向链表

前言 : 这一部份我们介绍的双向链表主要是说带头双向循环的结构 !

一、双向链表的构造

在不考虑有头无头、循环不循环的情况下，双向链表和单向链表在结构上的差别就是双向链表的结构多一个指针，指向的是前一个节点，这也让我们在许多操作上可以更加高效

结构比较
在这里插入图片描述

二、双向链表基本功能接口

2.1 定义结构体

// 定义结构体
typedef int LTDataType;
typedef struct ListNode {
	struct ListNode* prev;
	struct ListNode* next;

	LTDataType data;
}LTNode;

2.2 创建节点

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

	return node;

}

2.3 初始化

// 初始化
LTNode* LTInit() {
	// 这一部份是创建哨兵位头节点
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

哨兵位头节点的作用

  • 哨兵节点不存储实际数据，仅作为链表存在的标识，简化插入/删除操作的边界条件处理
  • 空链表时，哨兵节点的 next 和 prev 均指向自身，形成循环结构

这里我们说哨兵位节点不存储实际数据。在创建节点传入的 -1 只是为了创建哨兵位节点，实际上不会使用到。

要记得，只要头节点做完初始化后，phead就不可能为空，因此后面的断言都是在这个观念上进行断言。

2.4 销毁

//销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		ListErase(cur);
		cur = next;
	}
	free(phead);
}

2.5 打印

// 打印
void LTPrint(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead;

	printf("%d->", cur->data);
	cur = cur->next;
	while (cur != phead) {
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

2.6 判断是否为空

需要注意的是，如果是只剩下哨兵位节点，就不能继续进行删的动作

// 判断是否为空 若只有哨兵位的头结点就不能继续删
bool LTEmpty(LTNode* phead) {
	assert(phead);
	return phead->next == phead;
}

三、双向链表增加功能接口

3.1 尾插

// 尾插
void LTPushBack(LTNode* phead, LTDataType x) {
	assert(phead); //phead一定不为空
	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
	
	// 也可以直接使用后面的pos位置前插入
	// LTInsert(phead, x);
}

3.2 头插

需要注意的是，头插是在哨兵位节点的下一个节点插入，不是在哨兵位头节点前面插入

// 头插
void LTPushfFront(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyLTNode(x);
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;

	newnode->prev = phead;

	//LTInsert(phead, x); // 一样可以直接替换成pos位置前插入

}

3.3 在pos位置前插入

// pos位置前插入
void LTInsert(LTNode* pos, LTDataType x) {
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

四、 双向链表删除功能接口

4.1 尾删

// 尾删
void LTPopBack(LTNode* phead) {
	assert(phead);
	// 如果剩下哨兵位头节点，就不能继续删
	assert(!LTEmpty(phead));
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
	tail = NULL;
}

4.2 头删

// 头删
void LTPopFront(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	LTNode* next = cur->next;
	phead->next = next;
	next->prev = phead;
	free(cur);
	cur = NULL;
}

4.3 在pos位置处删除

//删除pos位置节点
void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

五、 双向链表查找功能接口

// 查找
LTNode* LTFind(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

六、 顺序表与链表的比较

在这里插入图片描述

七、完整代码

7.1 List.h

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

// 定义结构体
typedef int LTDataType;
typedef struct ListNode {
	struct ListNode* prev;
	struct ListNode* next;

	LTDataType data;
}LTNode;


// 创建节点
LTNode* BuyLTNode(LTDataType x);
//初始化
LTNode* LTInit();
// 销毁
void destroy();
// 打印
void LTPrint(LTNode* phead);
// 判断是否链表为空
bool LTEmpty();
//尾插
void LTPushBack(LTNode* phead, LTDataType x);
// 尾删
void LTPopBack(LTNode* phead);
// 头插
void LTPushfFront(LTNode* phead, LTDataType x);
// 头删
void LTPopFront(LTNode* phead);
// pos前插入
void LTInsert(LTNode* pos, LTDataType x);
// 在pos位置删除节点
void ListErase(LTNode* pos);
// 查找
LTNode* LTFind(LTNode* phead, LTDataType x);

7.2 List.c

#define _CRT_SECURE_NO_WARNINGS  1

#include "List.h"

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

	return node;

}
// 初始化
LTNode* LTInit() {
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
//销毁
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		ListErase(cur);
		cur = next;
	}
	free(phead);
}
// 打印
void LTPrint(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead;

	printf("%d->", cur->data);
	cur = cur->next;
	while (cur != phead) {
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
// 判断是否为空 若只有哨兵位的头结点就不能继续删
bool LTEmpty(LTNode* phead) {
	assert(phead);
	return phead->next == phead;
}
// 尾插
void LTPushBack(LTNode* phead, LTDataType x) {
	assert(phead); //phead一定不为空
	//LTNode* newnode = BuyLTNode(x);
	//LTNode* tail = phead->prev;

	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;
	LTInsert(phead, x);

}
// 尾删
void LTPopBack(LTNode* phead) {
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
	tail = NULL;
}
// 头插
void LTPushfFront(LTNode* phead, LTDataType x) {
	assert(phead);
	//LTNode* newnode = BuyLTNode(x);
	//newnode->next = phead->next;
	//phead->next->prev = newnode;
	//phead->next = newnode;

	//newnode->prev = phead;

	LTInsert(phead, x);

}
// 头删
void LTPopFront(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	LTNode* next = cur->next;

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

	free(cur);
	cur = NULL;


}
// pos位置前插入
void LTInsert(LTNode* pos, LTDataType x) {
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

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

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


}
//删除pos位置节点
void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

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

LTNode* LTFind(LTNode* phead, LTDataType x) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;

}
逐花归海.
关注
map和set的使用
让每一行代码都有改变世界的力量。
11-21 249
set的声明如下,T就是set底层关键字的类型set默认要求T支持小于比较,如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模板参数。set底层存储数据的内存是从空间配置器中申请的,如果需要可以自己实现内存池,传给第三个参数。一般情况下,我们都不需要传后两个模板参数。set底层是用红黑树实现,增删查效率是O(logN),迭代器遍历时走的搜索树的中序,所以是有序的。全面部分我们学习了vector/list等容器的使用,STL容器接口设计,高度相似。
数据结构（初阶 四）双向链表的实现
qq_45559559的博客
08-13 483
双向链表
【初阶数据结构】双向链表篇
2301_81072404的博客
08-18 405
数据结构预算法学习
初阶数据结构-双向链表
sushang的博客
10-08 156
将newnode的next指针指向phead的next，将phead的next指针指向newnode，将phead的next指针指向newnode，将newnode的prev指针指向phead。将tail的next指针指向newnode，将newnode的prev指针指向tail，将newnode的next指针指向phead，最后将phead的prev指针指向newnode。将phead的next指针指向next的next，将phead的next的prev指针指向phead，释放next指针。
数据结构初阶4 - 双向链表专题
2303_77692691的博客
02-17 327
注意：这里的“带头”跟前面我们说的“头节点”是两个概念，实际前面的在单链表阶段称呼不严谨，但是为了同学们更好的理解就直接称为单链表的头节点。带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨的”“哨兵位”存在的意义：遍历循环链表避免死循环。
数据结构与算法初阶4：链表—带头双向循环链表知识讲解
King_lm_Guard的博客
07-08 571
数据结构与算法初阶篇：带头双向循环链表相关知识讲解。
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
数据结构与算法篇初阶3：线性表—链表相关知识点讲解
King_lm_Guard的博客
07-07 985
数据结构与算法初阶篇：链表相关知识
C语言实现数据结构算法初阶算法
06-15
3. **双向循环链表**：双向链表不仅有指向下一个节点的指针，还有指向前一个节点的指针，形成循环结构。这使得在链表中的前后移动更为便捷，但增加了额外的存储开销。在需要双向操作或者循环遍历的场合，双向循环...
【C++ 初阶】List底层框架模拟实现
HenryBlog
11-21 1205
目录一、List框架搭建1. List简介2. List使用案例1. List简介1. List简介1. List简介1. List简介1. List简介1. List简介1. List简介二、完整代码 一、List框架搭建 1. List简介 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是带头双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。 与其他的序列式容器相比(array，ve
多线程---初阶
m0_65673419的博客
07-28 342
在了解多线程之前先来看看进程是什么。进程就是计算机完成一个工作的过程。 进程是如何被管理的呢？管理=描述（PCB）+组织⭐描述：进程控制块，这是一个C语言的结构体，一个结构体对象代表一个进程。PCB属性：1、pid：一个进程的标识符，同一个机器同一时刻不可能有两个进程的pid相同。2、内存指针：表示进程使用的内存空间的范围。3、文件描述符表：表示这个进程都打开了哪些文件，⭐组织：使用一定的数据结构来组织，比较常见的就是用双向链表。查看进程列表,本质上就是遍历操作系统内核中的这个链表，并显示其中的属性；创建一
数据结构模拟-用栈实现队列
kon-kon的博客
03-24 173
可以用两个栈来实现，一个栈保存入队的一端，也就是队尾，一个栈保存出队的一端，也就是队首。当遇到出队pop()时，如果stack out不为空，直接出栈，如果为空，那么先将stack in栈中所有的元素移动到stack out中，由于两个栈先进后出的特性，相当于负负得正，正好将stack in栈中想反的先后顺序更正了过来。用栈实现队列的基本操作，包括pop(), push(), empty(), peek().
数据结构--红黑树
最新发布
2401_88135404的博客
03-25 117
红黑树在插入删除时，不会破坏红黑树的特效，无需频繁调整树的形态，即便需要调整，一般可在常数级时间完成。红黑树查找操作时间复杂度=0(log2^n)-------------查找效率与AVL树同等数量级。红黑树是二叉排序树-------左子树结点值<=根结点值<=右子树结点值。⑤对每个结点，从该节点到任一叶结点的简单路径上，所含黑结点的数目相同。与二叉排序树相同，从根节点查找，小于根节点向左，大于根节点向右。③叶结点(外部结点、NULL结点、失败结点)均是黑色的。要求：（左根右，根叶黑，不红红，黑路同）
数据结构每日一题day1
weixin_52952158的博客
03-24 125
初始化指针：用两个下标分别指向顺序表的首元素（下标0）和末元素（下标length-1）。题目描述：设计一个高效算法，讲顺序表L的所有元素逆置。要求算法空间复杂度为O(1)算法思想：采用双指针法。交换元素：每次交换两个下标对应的元素，然后首指针右移，尾指针左移。终止条件：当首指针超过或等于尾指针时停止，确保所有元素被交换一次。复杂度分析：时间复杂度O(n)空间复杂度O(1)
数据结构 ——单链表
lrhhappy的博客
03-20 1112
单链表和顺序表相比可就好太多了，效率高不少，在进行头插和头删时的效率相差最大，顺序表在进行头插和头删时时间复杂度为O(n^2)，而在单链表中只需要更改几个指针就可以，效率大大提升，相信通过这篇文章可以让你清楚认识了解单链表。
基础算法01——二分查找（Binary Search）
学习笔记
03-24 210
二分查找算法：也称为**折半查找**，是一种在**有序数组**中查找特定元素的高效算法。
基于模糊PID算法的智能洗衣机控制器设计，实现洗衣过程智能化，能够监测衣物重量和污泥，实现洗涤时间、洗衣液投放的智能控制
huanghm88的专栏
03-24 119
以上代码实现了一个基于模糊PID算法的智能洗衣机控制器的基本功能。在实际应用中，你需要根据具体的硬件平台和传感器型号进行适当的调整。同时，需要将MATLAB仿真得到的模糊规则和PID参数应用到STM32单片机代码中，以实现更精确的控制。
数据结构之优先级队列
2301_80174936的博客
03-24 286
1. 使用时必须导入PriorityQueue所在的包，即：2. PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出 ClassCastException异常（类型转换异常，不能够转换成Comparable类型）3. 不能插入null对象，否则会抛出NullPointerException（空指针异常）4. 插入和删除元素的时间复杂度为O(log2N) 【树的高度】5.PriorityQueue底层使用了堆数据结构6.
数据结构栈和队列
2401_84421190的博客
03-24 438
⼀种特殊的线性表，其。进⾏数据插⼊和删除操作的⼀端称为栈顶，另⼀端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。：栈的操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。：栈的操作叫做出栈。。用什么来定义栈呢1.数组，可定义一个数组，最后面定义为栈顶，在最后面进行数据的加入和删除（定义一个数组有效数据为size,在size下标进行就好了）2.单链表，在末尾进行的话，找到尾结点很难，如果为n个数据，那么时间复杂度就为o(n),所以在头结点定义为栈顶，一样可以实现栈。
【第二月_day7】Pandas 简介与数据结构_Pandas_ day1
鹿鸣悠悠
03-24 470
以下是专为小白设计的 Pandas 简介与数据结构 学习内容，用最通俗的语言和案例讲解核心概念： 安装完成后，输入 进入 Python 环境，输入 验证是否成功（不报错即可） 二、Pandas 的核心数据结构 1. Series（一维数据） 定义：像一个带标签的列表，比如一列Excel数据创建方法： 基础操作： 2. DataFrame（二维表格） 定义：像 Excel 表格，由多列 Series 组成创建方法： 显示表格： 核心概念： 2. 选择数据 3. 添加/删除列
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值