数据结构学习之路--实现带头双向循环链表的详解(附C源码)

已于 2024-04-16 20:52:24 修改
阅读量783 收藏 35
点赞数 30
文章标签： 数据结构 学习 链表
于 2024-04-13 15:21:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74149710/article/details/137713221
版权

   嗨嗨大家~本期带来的内容是：带头双向循环链表的实现。在上期文章中我们提到过带头双向循环链表，那么它的实现又是怎样的呢？今天我们来一探究竟！

目录

前言 

一、认识带头双向循环链表

1 认识双向链表 

2 带头双向循环链表的定义

二、带头双向循环链表的实现 

2.1 定义

2.2 创建结点 

2.3 初始化 

方法一： 

方法二：

2.4 链表的判空

2.5 链表的尾插 

2.6 链表的头插 

方法一： 

方法二：

2.7 链表的尾删 

2.8 链表的头删 

2.9 在pos位置之前插入 

2.10  删除pos位置的结点

2.11 链表的长度

2.12 链表的打印

2.13 链表的销毁

三、总代码 

前言 

   我们在上期内容中讲过，链表结构是多样化的。但在实际中最常用的只有两种：无头单向非循环链表和带头双向循环链表。前者已经在上篇博客（http://t.csdnimg.cn/s8ieT）进行了全面的讲解，现在我们来认识并实现后者。

一、认识带头双向循环链表

1 认识双向链表 

   单链表虽然能够实现从任一结点出发沿着链能找到其前驱结点，但时间耗费是O(n)。如果希望从表中快速确定某一个结点的前驱，另一个解决方法就是在单链表的每个结点里再增加一个指向其前驱的指针域prev。这样形成的链表中就有两条方向不同的链，称之为双(向)链表。

   与单链表类似，双向链表也可增加头结点使双向链表的某些运算变得方便。同时双向链表也可以有循环表，称为双向循环链表。 由于在双向链表中既有前向链又有后向链，所以寻找任一结点的直接前驱结点与直接后继结点都变得非常便捷。

2 带头双向循环链表的定义

   带头双向循环链表：结构最复杂，一般用于单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

二、带头双向循环链表的实现 

2.1 定义

代码实现：

//定义
typedef int LTDataType;
 
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

分析：这里与单链表的定义不同，带头双向循环链表要定义两个指针：前驱指针prev和后继指针next。前驱指针prev用于指向当前结点的上一个结点，后继指针next用于指向当前结点的下一个结点。 

2.2 创建结点 

代码实现：

//创建结点
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟一个结点node
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
 
	//判空
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
 
	//前驱与后继结点均置为空
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
 
	return node;
}

分析：结点的创建主要是通过调用malloc函数来实现，初始化时要将前驱指针和后继指针都置为NULL。 

2.3 初始化 

  • 带头双向循环链表的初始化可以使用两种方法：传二级指针和设置返回值。

方法一： 

代码实现：

//初始化
void ListInit(LTNode** phead)
{
	//这里需要传入二级指针，即传地址，才能实现对链表的修改
 
	//判空
	assert(phead);
	
	//创建头结点
	*phead = BuyListNode(-1);
 
	//因为是带头双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	(*phead)->next = *phead;
	(*phead)->prev = *phead;
}

方法二：

代码实现：

初始化
LTNode* ListInit()
{
	//创建头结点
	LTNode* phead = BuyListNode(-1);
 
	//因为是带头循环双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	phead->next = phead;
	phead->prev = phead;
 
	//返回头结点
	return phead;
}

注意：

  • 若想要改变头指针，就要传二级指针；不需要改变头指针的话，便传入一级指针。
  • 在使用带头结点的单链表时：
  1. 初始化链表头指针需要传二级指针；
  2. 销毁链表需要传二级指针；
  3. 插入、删除、遍历、清空结点用一级指针即可。
  • 不带头结点的单链表，除了初始化和销毁，插入、删除和清空结点也需要二级指针。 

2.4 链表的判空

代码实现：

bool ListEmpty(LTNode* phead)
{
	//判空
	assert(phead);
 
	//如果phead->next等于phead，则链表为空，返回true
	//如果phead->next不等于phead，则链表不为空，返回false
	return phead->next == phead;
}

分析：若phead->next等于phead，则链表为空，返回true；若phead->next不等于phead，则链表不为空，返回false。 

2.5 链表的尾插 

代码实现：

//尾插
void ListPushBack(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//查找尾结点
	LTNode* tail = phead->prev;
 
	//原尾和新尾相互链接
	tail->next = newnode;
	newnode->prev = tail;
	//头结点和新尾相互链接
	newnode->next = phead;
	phead->prev = newnode;
}

分析：与单链表的尾插相比，带头双向循环链表的尾插不需要从头结点开始依次向后遍历，因为头结点的前驱结点便指向尾结点tail。在找到尾结点tail之后，便可将新结点newnode插入到尾结点tail的后面。此时newnode变为新的尾结点。 

2.6 链表的头插 

  • 带头双向循环链表的头插有两种方式实现。

方法一： 

代码实现：

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);

	//创建新结点
	LTNode* newnode = BuyListNode(x);

	//phead newnode next：三者不分先后顺序
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

方法二：

代码实现：

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
	//创建新结点
	LTNode* newnode = BuyListNode(x);
	
    //phead newnode phead->next：先处理后两个，再处理前两个
	phead->next->prev = newnode;
	newnode->next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
}

分析：当进行头插时，要注意结点之间插入的先后顺序，这里主要介绍两种方式：

  • 方式一：创建一个临时变量next，然后将头结点的下一个结点保存在next当中。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和next三个结点进行链接。三个结点不分先后顺序，直接进行链接即可。该方式最为简单，也最不容易出错；
  • 方式二：不创建临时变量next。首先调用BuyListNode(x)创建一个新结点newnode，然后将phead，newnode和phead->next三个结点进行链接。链接是关键：要先将后两个结点进行链接，然后再将前两个结点进行链接。三个结点一定要注意先后顺序，不可随意链接。 

2.7 链表的尾删 

代码实现：

//尾删
void ListPopBack(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//找尾结点
	LTNode* tail = phead->prev;
 
	//找尾结点的前一结点
	LTNode* tailPrev = tail->prev;
 
	//释放尾结点
	free(tail);
 
	tailPrev->next = phead;
	phead->prev = tailPrev;
}

分析： 在进行尾删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的尾结点tail，以及链表尾结点的前一个结点tailPrev；接着调用free函数释放尾结点tail，并将tailPrev作为新的尾结点；最后再将新的尾结点与头结点phead进行相连即可。

2.8 链表的头删 

代码实现：

//头删
void ListPopFront(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//tail记录第一个结点之后的下一个结点
	LTNode* tail = phead->next->next;
	
	//释放第一个结点
	free(phead->next);
 
	//将头结点和tail相链接
	phead->next = tail;
	tail->prev = phead;
}

分析：在进行头删之前，首先要判断链表是否为空，可以通过phead->next != phead进行判断，也可以调用ListEmpty(phead)函数进行判断；然后找到链表的第二个有效结点tail；接着调用free函数释放掉第一个有效结点，并将tail作为新的第一个有效结点；最后再将新的第一个结点tail与头结点phead进行相连即可。 

2.9 在pos位置之前插入 

代码实现：

//在pos前插入结点
void ListInsert(LTNode* pos, LTDataType x)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//prev newnode pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

分析：给定一个结点pos，如果是带头双向循环链表，那么pos之前的结点和pos之后的结点都是可知的。要在pos位置之前插入，首先要找到pos的前一结点prev，然后调用BuyListNode(x)创建一个新结点newnode，接着将prev，newnode和pos三个结点进行链接即可。此时pos位置的结点将由pos变为newnode。 

2.10  删除pos位置的结点

代码实现：

//删除pos位置的结点
void ListErase(LTNode* pos)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
	
	//查找pos的后一个结点
	LTNode* next = pos->next;
 
	//将前一个结点pre与后一个结点next相链接
	prev->next = next;
	next->prev = prev;
 
	//释放pos结点
	free(pos);
}

分析：在删除pos位置的结点之前，首先要找到pos位置的前一个结点prev，然后找到pos位置的后一个结点next，接着将结点prev与next相链接，最后再调用free函数释放掉pos结点即可。 

2.11 链表的长度

 代码实现：

//求链表长度（结点个数）
int ListSize(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前链表的第一个结点
	LTNode* cur = phead->next;
	
	//用于记录遍历过的结点数
	int size = 0;
 
	//从第一个结点开始依次向后遍历，直到遍历到头结点
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

2.12 链表的打印

代码实现：

//打印
void ListPrint(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向链表的第一个结点
	LTNode* cur = phead->next;
 
	//cur依次向后遍历，直到cur重新回到头结点
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

分析：设置一个临时变量cur，指向当前链表的第一个结点(非头结点)，然后依次向后遍历该链表，直到cur重新回到头结点phead的位置。 

2.13 链表的销毁

代码实现：

//销毁
void ListDestory(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前第一个结点
	LTNode* cur = phead->next;
 
	while (cur != phead)
	{
		//保存cur的下一个结点
		LTNode* next = cur->next;
 
		//删除cur
		ListErase(cur);
 
		//更新cur
		cur = next;
	}
 
	//释放头结点
	free(phead);
}

总结：可以在该链表的任意位置插入和删除（但不能删除head），也无需考虑特殊情况进行单独判断。 

三、总代码 

List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
 
//带头双向循环链表
 
//定义
typedef int LTDataType;
 
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;
 
//创建结点
LTNode* BuyListNode(LTDataType x);
 
//初始化：方法一
//void ListInit(LTNode** phead);
 
//初始化：方法二
LTNode* ListInit();
 
//判空
bool ListEmpty(LTNode* phead);
 
//尾插
//不用二级指针的原因：尾插时不会改变phead，因为它带哨兵位，尾插时不会对哨兵位进行修改
void ListPushBack(LTNode* phead, LTDataType x);
 
//头插
void ListPushFront(LTNode* phead, LTDataType x);
 
//尾删
void ListPopBack(LTNode* phead);
 
//头删
void ListPopFront(LTNode* phead);
 
//在pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x);
 
//删除pos位置的结点
void ListErase(LTNode* pos);
 
//链表长度
int ListSize(LTNode* phead);

//打印
void ListPrint(LTNode* phead);
 
//销毁
void ListDestory(LTNode* phead);
List.c

#include"List.h"

​//创建结点
LTNode* BuyListNode(LTDataType x)
{
	//动态开辟一个结点node
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
 
	//判空
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}
 
	//前驱与后继结点均置为空
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
 
	return node;
}
​​//初始化
void ListInit(LTNode** phead)
{
	//这里需要传入二级指针，即传地址，才能实现对链表的修改
 
	//判空
	assert(phead);
	
	//创建头结点
	*phead = BuyListNode(-1);
 
	//因为是带头双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	(*phead)->next = *phead;
	(*phead)->prev = *phead;
}

​​/*
//初始化
LTNode* ListInit()
{
	//创建头结点
	LTNode* phead = BuyListNode(-1);
 
	//因为是带头循环双向链表，故将头结点的前驱指针和后继指针均指向它们自己
	phead->next = phead;
	phead->prev = phead;
 
	//返回头结点
	return phead;
}
*/

//判空
​​bool ListEmpty(LTNode* phead)
{
	assert(phead);
 
	//如果phead->next等于phead，则链表为空，返回true
	//如果phead->next不等于phead，则链表不为空，返回false
	return phead->next == phead;
}
//尾插
​​void ListPushBack(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//查找尾结点
	LTNode* tail = phead->prev;
 
	//原尾和新尾相互链接
	tail->next = newnode;
	newnode->prev = tail;
	//头结点和新尾相互链接
	newnode->next = phead;
	phead->prev = newnode;
}
​//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);

	//创建新结点
	LTNode* newnode = BuyListNode(x);

	//phead newnode next：三者不分先后顺序
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}
​​//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	//判空
	assert(phead);
	//创建新结点
	LTNode* newnode = BuyListNode(x);
	
    //phead newnode phead->next：先处理后两个，再处理前两个
	phead->next->prev = newnode;
	newnode->next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
}
​​//尾删
void ListPopBack(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//找尾结点
	LTNode* tail = phead->prev;
 
	//找尾结点的前一结点
	LTNode* tailPrev = tail->prev;
 
	//释放尾结点
	free(tail);
 
	tailPrev->next = phead;
	phead->prev = tailPrev;
}
​​//头删
void ListPopFront(LTNode* phead)
{
	//判空
	assert(phead);
 
	//判断链表是否为空
	assert(phead->next != phead);
	//assert(!ListEmpty(phead));
 
	//tail记录第一个结点之后的下一个结点
	LTNode* tail = phead->next->next;
	
	//释放第一个结点
	free(phead->next);
 
	//将头结点和tail相链接
	phead->next = tail;
	tail->prev = phead;
}
​​//在pos前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
 
	//创建新结点
	LTNode* newnode = BuyListNode(x);
 
	//prev newnode pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}
​​//删除pos位置的结点
void ListErase(LTNode* pos)
{
	//判空
	assert(pos);
 
	//查找pos的前一个结点
	LTNode* prev = pos->prev;
	
	//查找pos的后一个结点
	LTNode* next = pos->next;
 
	//将前一个结点pre与后一个结点next相链接
	prev->next = next;
	next->prev = prev;
 
	//释放pos结点
	free(pos);
}
​​//求链表长度（结点个数）
int ListSize(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前链表的第一个结点
	LTNode* cur = phead->next;
	
	//用于记录遍历过的结点数
	int size = 0;
 
	//从第一个结点开始依次向后遍历，直到遍历到头结点
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}
	return size;
}
​​
//销毁
void ListDestory(LTNode* phead)
{
	//判空
	assert(phead);
 
	//cur指向当前第一个结点
	LTNode* cur = phead->next;
 
	while (cur != phead)
	{
		//保存cur的下一个结点
		LTNode* next = cur->next;
 
		//删除cur
		ListErase(cur);
 
		//更新cur
		cur = next;
	}
 
	//释放头结点
	free(phead);
}

​
test.c
 
#include"List.h"
 
void Test()
{
	LTNode* plist = NULL;
 
	//初始化
	plist = ListInit();
 
	//头插
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPushFront(plist, 5);
	ListPrint(plist);
 
	ListDestory(plist);
	ListPrint(plist);
}
 
int main()
{
	Test();
 
	return 0;
}

   大家学到这里，链表的知识分享已经接近尾声，综合本期文章以及前两篇博客来看，其实不难发现，对于任何一个数据结构，基本操作大致上都能归纳为创建销毁，增删改查。其中改建立在查的基础上。

   那么本期的内容就告一段落，有关于链表的总结也已经结束，此时的你是否对链表有了更深层次的了解和掌握呢？如果大家觉得这篇文章对你们有所帮助，记得给博主留下三连支持哈~你们的支持是我创作的最大动力！博主也会继续竭尽所能地为大家带来更加优质的内容，当然啦，或许我存在许多不足之处，欢迎各位佬们的指点！请相信相信的力量，一切也终有回甘！诸君加油~我们下期再会啦。

Yccsk♬
关注
  • 30
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
双向带头循环链表
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
链表 链表_使用C语言实现非循环双向链表_带头结点+尾结点
追梦之旅【数据结构篇】——详解C语言动态实现带头结点的双向循环链表结构
小梦的博客
02-22 1799
保姆式详解C语言动态实现带头结点的双向循环链表结构
C语言链表超详解
热门推荐
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
【数据结构初阶】：带头双向循环链表（用C语言实现，附图详解）
平凡的指针的博客
10-27 1549
文章目录一、带头双向循环链表二、带头双向循环链表实现思路三、链表指针和结点内存布局图四、带头双向循环链表的初始化五、带头双向循环链表接口实现：1.尾部插入数据2.头部插入数据3.尾部删除数据4.头部删除数据5.显示数据6.查找数据7.在结点前面插入数据8.删除当前位置数据9.内存释放六、对头插 尾插 头删 尾删的改造七、总结（附源码） 一、带头双向循环链表 前面我们实现了无头单向非循环链表，特性为：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构
【数据结构】带头+双向+循环链表（增、删、查、改）的实现_【附源码、图片示例】_ [初阶篇_ 复习专用]
Dream_Y.ocean的博客
05-06 1126
链表是一种物理存储结构上非连续、非顺序的存储结构数据元素的逻辑顺序是通过链表中的指针链接次序实现的❗链表也符合我们在顺序表中提及的线性表，即链表也是线性表的一种🥯Ⅱ.✨综上就是链表的概念啦~➡️简单来说链表是逻辑结构上类似于顺序表的连续的结构，但实际物理结构是不一定连续存储的【数据结构】单链表（增、删、查、改）的实现[初阶篇_复习专用]但今天，我们终点来看看链表的终极形态带头+双向+循环链表🍞二.✨综上就是带头+双向+循环链表接口实现的内容啦~➡️相信大家对带头+双向+循环链表🍭。...
【初阶数据结构】——带头双向循环链表（C描述）
m0_70980326的博客
11-21 1208
带头双向循环链表详解
双向带头结点链表全面详解（附带源码）
qq_51216031的博客
10-26 86
1、头插 2、尾插 3、随机插入 5、销毁 6、判空 7、打印 8、找元素 9、头删 10、尾删 11、总结
java数据结构-链表详解
m0_63526467的博客
05-04 3953
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2307
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
Java链表详解--通俗易懂(超详细,含源码)
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
链表-使用PHP实现的双向链表数据结构.zip
03-13
链表 链表_使用PHP实现的双向链表数据结构
数据结构之链表源码-思路清晰纯C
08-31
单链表 单循环链表 双链表 双循环链表 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
数据结构-栈
2202_75509654的博客
05-19 378
顺序栈：int maxlen;int top;}sqstack;
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
qq_50891451的博客
05-22 349
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
C-数据结构-单向链表（示例）
最新发布
aqiangdeba的博客
05-22 91
【代码】C-数据结构-单向链表（示例）
数据结构（队列）
wan__cheng的博客
05-22 95
概念：队列是一种线性表，它只能从一端插入数据，从另一端删除数据，在插入数据的一端称为队头，在删除数据的一端称为队尾。队列遵循先进先出的原则。队列的实现建议使用链表来实现，因为如果用数组的话出队列要调整数组，比较麻烦，而使用链表实现就可以避免这个问题。生动形象一点就跟我们日常排队一样，先排的人先走，后排的人后走。
java实现带头双向循环链表(附完整源码)
06-08
以下是Java实现带头双向循环链表的完整源码，供参考： ``` public class DoublyCircularLinkedList<T> { private Node<T> head; // 头节点 // 节点类 private static class Node<T> { T data; Node<T> prev; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值