外强中干——双向带头循环链表

已于 2023-05-12 23:54:49 修改
阅读量779 收藏
点赞数 3
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-05-12 23:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73390155/article/details/130630300
版权

前言：众所周知，链表有八种结构，由单向或双向，有头或无头，循环或不循环构成。在本篇，将介绍8种链表结构中最复杂的——双向带头循环链表。听着名字或许挺唬人的，但实际上双向带头循环链表实现起来比结构最简单的单向不带头不循环链表简单的多，是个“外强中干”的链表。这里只是说它名字唬人哦，实际上它是最优的链表结构，可以达到再任意位置插入，删除数据复杂度都是O(1)。（文末附有完整代码）

首先用你喜欢的IDE创建一个头文件和两个源文件，不同的文件具有以下不同的功能：

文件作用
list.h接口函数的声明
list.c接口函数的实现——链表的主体，文章的核心内容
test.c测试链表的运行逻辑
在这里插入图片描述下文将实现的11个链表接口
在这里插入图片描述双向循环链表图

这里是目录

接口

0.开始前的准备

头文件的包含；结构体的创建；.c文件引用.h文件

list.h

#include<stdio.h>
#include<assert.h>  //assert断言所需头文件
#include<stdlib.h>  //malloc动态开辟内存空间所需头文件
#include<stdbool.h> //在c语言中使用bool类型所需头文件，下文实现的ListEmpty函数用到

typedef int LTDataType; //因不知链表中存储的是什么数据类型，所以用重命名，要修改数据类型时直接将int换成其它的即可
typedef struct ListNode  
{
	LTDataType data;
	struct ListNode* next;  //指向后一个结点的指针
	struct ListNode* prev;  //指向前一个结点的指针
}ListNode;      //将结构体struct ListNode 重命名为 ListNode,方便操作

list.c

#include"list.h"  //引用头文件

test.c

#include"list.h"  //引用头文件

1.创建返回链表的头结点

这里的头结点就是我们常说的哨兵位，需要注意的是，哨兵位中不存储数据（即不给data赋值）。

list.h

//1.创建返回链表的头结点.
ListNode* ListInit();  //在头文件中声明

list.c

//要创建一个链表的结点，就需要开辟一个结构体，因此在.c文件中创建一个开辟新结点的函数，
//在下文中需要创建新结点时直接引用此函数即可
ListNode* ListCreate(LTDataType x) 
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); //malloc一个结构体
	if (newnode == NULL) //此处if判断malloc是否成功，常规情况下都会成功，毕竟失败了咱们链表不就创建失败了吗？
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x; //给数据赋值
	newnode->next = NULL;  //next指针置空
	newnode->prev = NULL;  //prev指针置空
	return newnode;
}

//1.创建返回链表的头结点
ListNode* ListInit()
{
	ListNode* pHead = ListCreate(-1); //这里的头结点随便给一个值,开头时提过头结点不存储数据，
//这样不是前后矛盾吗？不用担心，后文中的打印函数实现时并不会打印头结点。
	pHead->next = pHead;  //因为链表只有一个头结点，所以前后指针都指向自己
	pHead->prev = pHead;
	return pHead;
}

这里是引用

test.c

int main()
{
	ListNode* plist = ListInit();  
	return 0;
}

2.链表销毁

将每个创建的结点通过free函数释放，需要注意的是，因为传参我们传的是一级指针，所以需要在使用完销毁函数后手动置空。

list.h

//2.链表销毁
void ListDestory(ListNode* pHead);

list.c

//2.链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);  //断言一下pHead是否传有效数据进来
	ListNode* cur = pHead->next; //存储头结点的后一个结点
	while (cur != pHead)  //从头结点的后一个结点遍历到头结点停止循环
	{
		ListNode* next = cur->next;  //存储后一个结点
		free(cur);  //释放当前结点
		cur = next; //将cur指向后一个结点,使循环继续
	}
	free(pHead);
	//pHead = NULL; 置空无效，因为形参的改变不影响实参，在主函数中置空。
}

test.c

#include"list.h"
int main()
{
	ListNode* plist = ListInit();
	ListDestory(plist);
	plist = NULL;  //手动置空
	return 0;
}

3.链表打印

从头到尾遍历打印，注意不要打印头结点（哨兵位）

list.h

//3.链表打印
void ListPrint(ListNode* pHead);

list.c


//3.链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	//打印头结点
	printf("guard<==>"); //为了打印的美观，哨兵位这样表示
	ListNode* cur = pHead->next; //存储头结点的后一个结点
	while (cur != pHead)  //从头结点的后一个结点遍历到头结点停止循环
	{
		printf("%d<==>", cur->data);  //打印输出
		cur = cur->next;  //将cur指向后一个结点,使循环继续
	}
}

test.c

#include"list.h"
int main()
{
	ListNode* plist = ListInit();
	ListPrint(plist);
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时链表中只有头结点，显示台窗口如下：
在这里插入图片描述

4.链表尾插

链表中的重要接口之一，在单链表中，进行尾插操作的话需要从头找到尾结点，而在双向链表中，头结点的前一个结点就是尾结点（pHead->prev）。从这里就可以看出双向带头循环链表实现起来的简单之处。

list.h

//4.链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);

list.c

//4.链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) //插入拥有两个参数，第二个参数为你要插入的数值
{
	assert(pHead); //断言
	ListNode* newnode = ListCreate(x); //插入需要创建新结点，这里我们开头第1部分创建的ListCreate函数就有了用武之地。
	struct ListNode* tail = pHead->prev; //存储原来的尾结点，注意这个结点的存储会让你的尾插实现写的很舒服
	newnode->next = pHead;  //实现链接
	newnode->prev = tail;   
	tail->next = newnode;   
	pHead->prev = newnode;  //注意这里的pHead->prev不要再用tail代替了，因为改变tail并不会改变pHead->prev。
}

在这里插入图片描述

以上图为例，进行尾插操作的话，需要将新结点与d3，head链接起来，同时断开head和原尾结点d3。
上面的代码使用tail结构体指针存储了pHead->prev,这样的话下面实现链接的4行代码就可以是任意顺序，若是没有tail的话，必须在结尾改变pHead->prev，因为前面几行代码需要用到pHead->prev，若是改了它，则代码不能实现。

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 4);  //尾插4
	ListPushBack(plist, 3);  //尾插3
	ListPushBack(plist, 2);  //尾插2
	ListPushBack(plist, 1);  //尾插1
	ListPrint(plist);
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：
在这里插入图片描述

5.链表判空

很简单的一个接口，返回一个bool类型的值。因在链表尾删中需要用到，所以将其放在尾删前

list.h

//5.链表判空
bool ListEmpty(ListNode* pHead);

list.c

bool ListEmpty(ListNode* pHead)
{
	assert(pHead); //断言
	return pHead->next == pHead; // 若是头结点的后一个结点还是头结点，说明链表中只有头结点，
	//而头结点不存放有效数据，因此只有头结点的链表就是空链表。 
	//该语句为真，则返回true，若为假，则返回false
}

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	if (ListEmpty(plist))
	{
		printf("链表为空\n");
	}
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：
在这里插入图片描述

6.链表尾删

链表中的重要接口之一，双向链表找尾很方便，即pHead->prev。删除操作比起插入操作实现起来更简单。

list.h

//6.链表尾删
void ListPopBack(ListNode* pHead);

list.c

//6.链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);  //断言
	assert(!ListEmpty(pHead));
	ListNode* tail = pHead->prev;
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	free(tail);
	tail = NULL;
}

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListPrint(plist);  //第一行打印
	ListPopBack(plist);
	printf("\n");
	ListPrint(plist);  //第二行打印
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：尾删了一个0
在这里插入图片描述

7.链表头插

list.h

//7.链表头插
void ListPushFront(ListNode* pHead, LTDataType x);

list.c

//头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead); //断言
	ListNode* newnode = ListCreate(x);  //创建新结点
	ListNode* head = pHead->next;   //存放头结点的后一个结点
	newnode->next = head;
	head->prev = newnode;
	pHead->next = newnode;
	newnode->prev = pHead;
}

这里是引用

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListPushFront(plist, 3);
	ListPrint(plist);  //第二行打印
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：头插一个3
在这里插入图片描述

8.链表头删

跟头删一样，删除操作都要进行判空，若是空链表，则不能再进行删除操作。

list.h

list.c

//链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(!ListEmpty(pHead));  
	ListNode* head = pHead->next;
	head->next->prev = pHead;
	pHead->next = head->next;
	free(head);
	head = NULL;
}

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListPrint(plist);  //第一行打印
	printf("\n");
	ListPopFront(plist); //头删
	ListPrint(plist);  //第二行打印
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：头删一个2
在这里插入图片描述

9.链表查找

查找链表中是否存在指定的数，若存在，则返回这个结点，若不存在，则返回NULL。

list.h

//9.链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);

list.c

//9.链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead); //断言
	ListNode* cur = pHead->next;  //存储头结点的后一个结点
	while (cur != pHead)
	{
		if (cur->data == x)  //如果是，则返回该结点
			return cur;
		cur = cur->next;   
	}
	return NULL;  //如果没有，则返回NULL
}

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListNode* pplist = ListFind(plist,2);
	if (pplist)
	{
		printf("链表中包含2");
	}
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：查找链表中有没有2

在这里插入图片描述

10.在链表pos位置前插入

list.h

//10.在链表pos位置前插入
void ListInsert(ListNode* pos, LTDataType x);

list.c

//10.在链表pos位置前插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos); //断言
	ListNode* newnode = ListCreate(x); //创建新结点
	newnode->next = pos;  
	newnode->prev = pos->prev;
	pos->prev->next = newnode;
	pos->prev = newnode;
}

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListNode* pos = ListFind(plist,2);
	if (pos)
	{
		ListInsert(pos, 3);
	}
	ListPrint(plist);
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：在2的前面插入3
在这里插入图片描述

11.删除链表pos位置的结点

list.h

//11.删除链表pos位置的结点
void ListErase(ListNode* pos);

list.c

//11.删除链表pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos); //断言
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

在这里插入图片描述

test.c

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListPrint(plist);  //第一行打印
	printf("\n");
	ListNode* pos = ListFind(plist,2);
	if (pos)
	{
		ListErase(pos);  //删除2
	}
	ListPrint(plist);  //第二行打印
	ListDestory(plist);
	plist = NULL;
	return 0;
}

此时显示台窗口如下：查找链表中是否有2，若有，则删除2（仅删除一个）
在这里插入图片描述

至此，双向带头循环链表的11个接口就写完了。怎么样，是不是感觉实现起来非常简单，说它"外强中干"丝毫为过吧。

完整代码

list.h

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

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

//1.创建返回链表的头结点.
ListNode* ListInit();
//2.链表销毁
void ListDestory(ListNode* pHead);
//3.链表打印
void ListPrint(ListNode* pHead);
//4.链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
//5.链表判空
bool ListEmpty(ListNode* pHead);
//6.链表尾删
void ListPopBack(ListNode* pHead);
//7.链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
//8.链表头删
void ListPopFront(ListNode* pHead);
//9.链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
//10.链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
//11.链表删除pos位置的结点
void ListErase(ListNode* pos);

list.c 核心代码——接口的实现

#include"list.h"  //引用头文件

//要创建一个链表的结点，就需要开辟一个结构体，因此在.c文件中创建一个开辟新结点的函数，
//在下文中需要创建新结点时直接引用此函数即可
ListNode* ListCreate(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); //malloc一个结构体
	if (newnode == NULL) //此处if判断malloc是否成功，常规情况下都会成功，毕竟失败了咱们链表不就创建失败了吗？
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x; //给数据赋值
	newnode->next = NULL;  //next指针置空
	newnode->prev = NULL;  //prev指针置空
	return newnode;
}

//1.创建返回链表的头结点
ListNode* ListInit()
{
	ListNode* pHead = ListCreate(-1); //这里的头结点随便给一个值,开头时提过头结点不存储数据，
	//这样不是前后矛盾吗？不用担心，后文中的打印函数实现时并不会打印头结点。
	pHead->next = pHead;  //因为链表只有一个头结点，所以前后指针都指向自己
	pHead->prev = pHead;
	return pHead;
}

//2.链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next; //存储头结点的后一个结点
	while (cur != pHead)  //从头结点的后一个结点遍历到头结点停止循环
	{
		ListNode* next = cur->next;  //存储后一个结点
		free(cur);  //释放当前结点
		cur = next; //将cur指向后一个结点
	}
	free(pHead);
	//pHead = NULL; 置空无效，因为形参的改变不影响实参，在主函数中置空。
}

//3.链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	printf("guard<==>"); //为了打印的美观，哨兵位这样表示
	ListNode* cur = pHead->next; //存储头结点的后一个结点
	while (cur != pHead)  //从头结点的后一个结点遍历到头结点停止循环
	{
		printf("%d<==>", cur->data);  //打印输出
		cur = cur->next;  //将cur指向后一个结点,使循环继续
	}
}

//4.链表尾插
void ListPushBack(ListNode* pHead, LTDataType x) //插入拥有两个参数，第二个参数为你要插入的数值
{
	assert(pHead); //断言
	ListNode* newnode = ListCreate(x); //插入需要创建新结点，这里我们开头第1部分创建的ListCreate函数就有了用武之地。
	struct ListNode* tail = pHead->prev;  //存储原来的尾结点
	newnode->next = pHead;  //实现链接
	tail->next = newnode;
	pHead->prev = newnode;  //注意这里的pHead->prev不要再用tail代替了，因为改变tail并不会改变pHead->prev。
	newnode->prev = tail;
	
}

//5.链表判空
bool ListEmpty(ListNode* pHead)
{
	assert(pHead);
	return pHead->next == pHead; //该语句为真，则返回true，若为假，则返回false
}

//6.链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);  //断言
	assert(!ListEmpty(pHead));
	ListNode* tail = pHead->prev;
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	free(tail);
	tail = NULL;
}

//7.链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead); //断言
	ListNode* newnode = ListCreate(x);  //创建新结点
	ListNode* head = pHead->next;   //存放头结点的后一个结点
	newnode->next = head;
	head->prev = newnode;
	pHead->next = newnode;
	newnode->prev = pHead;
}

//8.链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	assert(!ListEmpty(pHead));
	ListNode* head = pHead->next;
	head->next->prev = pHead;
	pHead->next = head->next;
	free(head);
	head = NULL;
}

//9.链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead); //断言
	ListNode* cur = pHead->next;  //存储头结点的后一个结点
	while (cur != pHead)
	{
		if (cur->data == x)  //如果是，则返回该结点
			return cur;
		cur = cur->next;
	}
	return NULL;  //如果没有，则返回NULL
}

//10.在链表pos位置前插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos); //断言
	ListNode* newnode = ListCreate(x); //创建新结点
	newnode->next = pos;
	newnode->prev = pos->prev;
	pos->prev->next = newnode;
	pos->prev = newnode;
}

//11.删除链表pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos); //断言
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

test.c 该文件随大家喜欢测试

#include"list.h"  //引用头文件
int main()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 2);
	ListPushBack(plist, 1);
	ListPushBack(plist, 0);
	ListPrint(plist);  //第一行打印
	printf("\n");
	ListNode* pos = ListFind(plist,2);
	if (pos)
	{
		ListErase(pos);  //删除2
	}
	ListPrint(plist);  //第二行打印
	ListDestory(plist);
	plist = NULL;
	return 0;
}

文末BB：对哪里有问题的朋友，可以在评论区留言，若哪里写的有问题，也欢迎朋友们在评论区指出，博主看到后会第一时间确定修改。最后，制作不易，如果对朋友们有帮助的话,希望能给点点赞和关注.
在这里插入图片描述

溪读卖
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; ...
链表Leetcode/牛客习题讲解（附带双指针，带环链表的拓展及证明）
Protein_zmm的博客
04-05 292
移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 思路：定义一个cur指向当前位置的指针，prev为cur前一个指针，cur一直往后遍历，如果cur指向的值为val，就改变指向 struct ListNode* removeElements(struct ListNode* head, int val
[ 链表OJ题 6 ] 链表分割 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针
CSDN博客
03-20 894
目录 题目来源： 代码实现： 1、不带有哨兵位的头结点。 2、带有哨兵位的头结点。 分析过程： 1、不带有哨兵位的头结点。 2、带有哨兵位的头结点。 题目来源： 链表分割_牛客题霸_牛客网 (nowcoder.com) 题目描述： 代码实现： 1、不带有哨兵位的头结点。 class Partition { public: ListNode* partition(ListNode* pHead, int x) { // write code her.
链表分割——现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
m0_46613023的博客
01-31 1369
题目：链表分割 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 解答一： 思想：有头节点 class Partition { public: ListNode* partition(ListNode* pHead, int x) { ListNode*cur,*lessHead,*lessTail,*moreHead,*moreTail;
现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。
小雨的博客
10-25 1159
采用方法： 尾插法： 1.需要知道两个线段开始和结束 bs be as ae = null； 2.定义一个cur遍历原来的单链表 3.如果cur.data<x放到第一个线段，如果相反，就放到第二个线段 4.cur为空的时候就遍历完了 注意： 1.如果第一个段没有数据，就返回第二段的开头as 2.be和as进行拼接 bs.next = as; //现有一链表的头指针 ListNode* pHead，给一定值x， // 编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据
C/C++数据结构（三） —— 双向带头循环链表
热门推荐
Edison's 小宇宙
08-16 1万+
【数据结构系列】链表之双向带头循环链表的基本操作
循环链表和双向链表.ppt
09-20
带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家...
Python双向循环链表实现方法分析
09-20
主要介绍了Python双向循环链表,结合实例形式分析了Python双向链表的定义、遍历、添加、删除、搜索等相关操作技巧,需要的朋友可以参考下
双向循环链表使用实例.doc
09-21
废话不多说，直接上CPP代码，算法的重要性不用多说。
《征服数据结构》栈
数据结构和算法
06-12 214
摘要：1，栈的介绍2，栈的链表实现3，栈的数组实现1，栈的介绍栈(stack)又称堆栈，是一种特殊的线性表，只能对栈顶添加和删除元素，它是一种后进先出(LIFO, Last In First Out)的数据结构。栈的两种基本操作：压栈(push)和出栈(pop)。压栈：将数据放入堆栈顶端。出栈：将堆栈顶端数据移除。堆栈只能操作一端，我们前面讲过双端队列，就是两端都可以添加和删除元素，如果把双端队列...
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1209
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
数据结构(4):串
qq_64279967的博客
06-10 498
字符串数据结构三要数：逻辑结构、存储结构、运算子串必须是连续的！空格也是一个字符！每个空格字符占1B。
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 878
二叉树顺序结构——堆的结构与源代码实现
【数据结构（邓俊辉）学习笔记】图04——双连通域分解
weixin_44399845的博客
06-10 979
双连通分量 BCC 双连通域
[C][数据结构][排序][下][快速排序][归并排序]详细讲解
最新发布
SnowK博客
06-14 4509
[C][数据结构][排序][下][快速排序][归并排序]详细讲解
数据结构进阶——AVL树
weixin_73870552的博客
06-09 1073
学习本章，需要大家先掌握搜索二叉树，了解键值对pair。int _bf;// balance factor 平衡因子, _kv(kv), _bf(0){}该节点的定义是一个三叉链，_left和_right分别指向左右子树，_parent指向父节点；节点中存储的有效数据为pair，类型的键值对；_bf为平衡因子，在此我们定义为右树高度减去左树高度，用来控制左右子树的高度（注意：平衡因子只是其中一种控制平衡的手段，并不是唯一的）；定义了一个模版构造函数，以便后续使用。
Day01 数据结构概述
qq_59111928的博客
06-13 446
数据：能被计算机存储和识别的信息。文字、图形、视频、音频数据结构：计算机存储数据和组织数据的方式。
【数据结构（邓俊辉）学习笔记】图05——优先级搜索
weixin_44399845的博客
06-10 561
优先级搜索 PFS
带头结点的双向循环链表操作集
04-30
带头结点的双向循环链表是在双向循环链表的基础上增加了一个头结点，可以方便地进行插入、删除等操作。以下是带头结点的双向循环链表的常见操作： ```c++ // 双向循环链表节点结构体 template struct Node { T ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

溪读卖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值