线性表【双向循环链表基本定义与操作】（带头结点）

已于 2024-08-14 16:03:17 修改
阅读量624 收藏 15
点赞数 28
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2024-08-14 16:01:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82676816/article/details/141172590
版权

1.双向循环链表的特征与图解

  • 让头结点的 前驱指针 指向 链表的最后一个结点
  • 让 最后一个结点 的后继指针 指向 头结点。

在这里插入图片描述
在这里插入图片描述

2.双向循环链表的重要操作

1.双向循环链表的结构定义

双向循环链表的结构与双向链表完全一致，不同之处在于它的尾结点的next指针指向头结点，而头结点的prior指针指向尾结点，从而形成一个循环。

//1.双向循环链表的结构定义（与双向链表完全一致）
typedef struct DNode
{
	ElemType data;// 数据域
	struct DNode* prior, * next; //前驱和后继指针
}DNode,*HLinkList;
//HNode * 用来定义结点指针
//HLinkList  用来定义链表指针

2.双向循环链表的初始化操作

InitLinkList(HLinkList* L)
1.双向循环链表的头结点和双向链表有所区别

双向链表初始化时，其头结点的next和prior分别指向NULL
双向循环链表初始化时，其头结点的next和prior分别指向自己，构成一个环

2.算法步骤：

（1）初始化头结点内存空间
（2）初始化头结点两个指针域指向自身

// 2. 双向循环链表的初始化操作
bool InitLinkList(HLinkList* L)
{
	// 1 为链表的头结点分配内存
	*L = (DNode*)malloc(sizeof(DNode));

	// 2 检查内存分配是否成功
	if (*L == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	// 3 初始化头结点的前驱和后继指针，指向自身，形成空的循环链表
	(*L)->next = *L;
	(*L)->prior = *L;

	// 4 返回初始化成功的标志
	return true;
}

3.双向循环链表的判空操作

DLinkListEmpty(HLinkList L)
1.算法步骤：

（1）检查头指针是否为NULL，如果是，则链表未初始化，可以认为是空
（2）若头结点的后继和前驱指针指向自身，则链表为空

// 3. 双向循环链表的判空操作
bool DLinkListEmpty(HLinkList L)
{
	//1 如果链表指针为空，则链表为空
	if (L == NULL)
	{
		return true;
	}

	//2 如果链表的头结点的后继和前驱指针指向自身，则链表为空
	//这里可以取其一，但是为了严谨性，取两者
	if (L->next == L&&L->prior==NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

4.双向循环链表的按位插入操作

InsertDLinkList(HLinkList L, int i, ElemType e)
1.注意事项：
1.循环的终止条件：

由于链表是循环链表，因此终止条件不能直接使用 p != L；
应通过 p->next != L 来终止遍历
那么相应的 i 大于链表长度加1的情况的判断就有所不同

2.插入时指针的修改：
2.1正常情况下的插入（在表中 头结点 与 尾结点之间 任意位置插入）与双向链表的插入步骤完全一致,不需要考虑头尾结点的指针域的指向

假设在p结点与p->next结点中插入一个新结点s
这里的p结点相当于指向待插入结点的前一个结点

  • （1）首先解决新结点的前驱的指向
  • （2）其次解决新结点的后继的指向
  • （3）然后解决p->next结点的前驱指向
  • （4）最后再解决p结点的后继指向
  <1>s->prior=p;//改变新结点前驱指向
  <2>s->next=p->next;//改变新结点后继指向
  <3>p->next->prior=s;//改变p->next结点前驱指向
  <4>p->next=s;//改变p结点后继指向

图解图下：
在表中 头结点 与 尾结点之间任意位置插入
在这里插入图片描述

2.2空表尾部插入，需要注意改变头结点的prior与next域指向，以形成完整的环
<1>s->prior = p;//等价于s->prior =L;
<2>s->next = p->next;//等价于s->next = L;
<3>L->prior = s;	
<4>L->next = s;

空表尾部插入
在这里插入图片描述

2.算法步骤：

（0） 错误处理:头结点不存在 或 i小于1
（1）初始化临时指针p指向头结点
（2）初始化计数器为0
（3）循环查找第i-1个结点的位置（注意终止条件：p->next != L）
（4）异常判断（i大于表长加1的情况（该插入位置错误））
（5）建立并初始化插入结点
（6）空表尾部插入操作（注意改变头结点的prior与next域）
（7）非空表的尾部插入或一般插入操作(与双向链表的正常插入过程一致)

// 4. 双向循环链表的按位插入操作
// 由于链表是循环链表，因此终止条件不能直接使用 p != L；
// 应通过 p->next != L 来终止遍历
bool InsertDLinkList(HLinkList L, int i, ElemType e)
{
	//[0]错误处理:头结点不存在 或 i小于1
	if (L == NULL || i < 1)
	{
		return false;
	}

	//[1]初始化临时指针p指向头结点
	DNode* p = L;

	//[2]初始化计数器为0
	int j = 0;

	//[3]循环查找第i-1个结点的位置
	//p->next!=L:
		//1.保证首元结点不存在时，不进入循环
		//2.保证i大于表长时， p指向尾结点，终止循环（此时如果待插入位置为尾结点的下一个结点，这是有效的，所以i大于表长加1的情况需要特判）
	//j<i-1:
		//正常情况下，找到第i-1个结点
	while (p->next != L && j < i - 1)
	{
		p = p->next;
		j++;
	}

	//[4]异常判断
	//p->next == L && j != i - 1:
		//i大于表长加1的情况（该插入位置错误）
	if (p->next == L && j != i - 1)
	{
		return false;
	}

	//[5]建立并初始化插入结点
	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	s->data = e;

	//[6]空表尾部插入操作（注意改变头结点的prior与next域）
	// 此时 p 指向头结点，且链表为空（头结点的 next 和 prior 都指向头结点自身）
	if (p->next == L && p->prior == L)
	{
		s->prior = p;//等价于s->prior =L;
		s->next = p->next;//等价于s->next = L;
		//当前p指向空表的头结点，并不存在p->next 结点，所以直接更改头结点的prior,next域即可(为了维护循环结构的完整性)
		L->prior = s;
		L->next = s;
	}
	//[7]非空表的尾部插入或一般插入操作(与双向链表的正常插入过程一致)
	else
	{
		s->prior = p;
		s->next = p->next;//先解决待插入结点的前驱后继指向
		

		p->next->prior = s;//然后解决 待插入结点 后继结点 的前驱指向
		p->next = s;//最后解决 待插入结点 前驱结点的 后继指向      
	}
	return true;
}

5. 双向循环链表的按位删除操作（与双向链表的删除过程完全一致）

DeleteDLinkList(HLinkList L, int i, ElemType *e)
1.思路回顾

假设删除p结点，即待删除结点

  • （1）首先解决 待删除结点 前驱结点的 后继指向
  • （2）其次解决 待删除结点 后继结点的 前驱指向
  • 注意：两者的顺序可以更换
2.几种删除情况的分析：

只有一个元素时删除首元结点
在这里插入图片描述

正常情况下删除尾结点
在这里插入图片描述

正常情况下删除中间结点
在这里插入图片描述

3.算法步骤：

（0）错误处理:头结点不存在 或 i小于1
（1）初始化临时指针p指向首元结点
（2）初始化计数器为1
（3）循环查找第i个结点的位置
（4）异常判断（主要是i大于表长的情况）
（5）核心：删除结点并释放空间


// 5. 双向循环链表的按位删除操作(与双向链表的删除过程完全一致,但是注意终止条件)
bool DeleteDLinkList(HLinkList L, int i, ElemType *e)
{
	//[0]错误处理:头结点不存在 或 i小于1
	if (L == NULL || i < 1)
	{
		return false;
	}

	//[1]初始化临时指针p指向首元结点
	DNode* p = L->next;
	
	//[2]初始化计数器为1
	int j = 1;


	//[3]循环查找第i个结点的位置
	//p!=L:
		//1.保证首元结点不存在时，不进入循环
		//2.保证i大于表长时,p指向尾结点next域（L），终止循环（比如：i=表长加1：此时待删除位置是尾结点 的后面 该位置是头结点的位置）
	//j<i-1:
		//正常情况下，找到第i个结点
	while (p != L && j < i)
	{
		p = p->next;
		j++;
	}

	//[4]异常判断
	//p==L:
		//1.首元结点不存在的情况（空表）
		//2.i大于表长的情况（该删除位置为头结点）
	if (p == L)
	{
		return false;
	}

	//[5]核心：删除结点:更新前驱和后继结点的指针（只要不删除头结点就是对的）
	*e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;

	free(p);//释放待删除结点空间

	return true;
}

6. 双向循环链表的头插法建立

bool CreateDLinkList_H(HLinkList* L, int n)
1.插入分析：

插入到空表表头（实际上与按位插入操作中插入到空表表头的操作完全一致）
在这里插入图片描述

插入到非空表表头（同样与按位插入操作中插入到正常位置的操作思路一致）
在这里插入图片描述

2.算法步骤：

（1）建立链表头结点并初始化next与prior域 指向自身
（2）循环插入新结点到表头
<1>初始化新结点
<2>改变指针指向(与按位插入的操作大同小异)
<2.1>s插入到空表表头
<2.2>s插入到非空表表头

// 6. 双向循环链表的头插法建立
bool CreateDLinkList_H(HLinkList* L, int n)
{
	//[1]建立链表头结点并初始化next与prior域：注意指向自身
	*L = (DNode*)malloc(sizeof(DNode));

	if ((*L) == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	(*L)->next = (*L);
	(*L)->prior = (*L);

	DNode* s;

	//[2]循环插入新结点到表头
	for (int i = 0; i < n; i++)
	{
		//<1>初始化新结点
		s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL)
		{
			printf("内存分配失败！\n");
			return false;
		}

		scanf_s("%d", &s->data);

		//<2>改变指针指向(与按位插入的操作大同小异)
		//<2.1>s插入到空表表头
		if ((*L)->next == (*L) && (*L)->prior == (*L))
		{
			//如果链表为空，将新结点插入到头结点之后
			s->prior = *L;
			s->next = *L;
			(*L)->next = s;
			(*L)->prior = s;
		}
		//<2.2>s插入到非空表表头
		else
		{
			//如果链表非空，将新结点插入到头结点之后
			s->prior = (*L);
			s->next = (*L)->next;
			(*L)->next->prior = s;
			(*L)->next = s;
		}
	}

	return true;
}

7.双向循环链表的尾插建立：

1.插入分析：
  • 与双向链表相似，由于尾指针永远更新指向最新的尾结点，故后续的插入操作与第一次插入操作完全一致。
  • 但是在改变指针指向的时候要注意改变头结点的prior域指向最新的尾结点，这是双向循环链表的特殊结构

插入到表尾
在这里插入图片描述

2.算法步骤：

（1）建立链表头结点并初始化next与prior域（注意指向自身）
（2）初始化尾指针，指向链表的头结点
（3）循环插入新结点到表尾
<1> 初始化新结点
<2> 改变指针指向 (插入到尾部 且 不需要特判)
<2.1>先解决新结点的next与prior域
<2.2> 再解决当前尾结点的next域 并 更新尾指针指向
这里着重注意更新头结点的prior域，以保证循环结构的完整性

// 7.双向循环链表的尾插建立
bool CreateDLinkList_T(HLinkList* L, int n)
{
	// [1] 建立链表头结点并初始化next与prior域（注意指向自身）
	*L = (DNode*)malloc(sizeof(DNode));
	if (*L == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	(*L)->next = (*L);  // 头结点的next指针指向自身，形成循环
	(*L)->prior = (*L); // 头结点的prior指针指向自身，形成循环

	// [2] 初始化尾指针，指向链表的头结点
	DNode* t = (*L);
	
	DNode* s; 

	// [3] 循环插入新结点到表尾
	for (int i = 0; i < n; i++)
	{
		// <1> 初始化新结点
		s = (DNode*)malloc(sizeof(DNode));  
		
		if (s == NULL)
		{
			printf("内存分配失败！\n");
			return false;
		}

		scanf_s("%d", &s->data);  


		// <2> 改变指针指向 (插入到尾部 且 不需要特判)
		//<2.1>先解决新结点的next与prior域
		s->prior = t;
		s->next = *L;//注意循环结构的完整性  
		
		//<2.2> 再解决当前尾结点的next域 并 更新尾指针指向
		//这里着重注意更新头结点的prior域，以保证循环结构的完整性
		t->next = s;   // 更新当前尾结点的next域
		(*L)->prior = s; // 更新头结点的prior域指向新结点（保证循环结构的完整性）

		t = s;  // 更新尾指针t，指向新的尾结点
	}

	return true;
}

8.双向循环链表的整表输出(与单链表完全一致)

printDLinkList(HLinkList L)
1.算法步骤：

（0）错误处理: 头结点不存在或首元结点不存在
（1）初始化临时指针p指向首元结点
（2）错误处理: 首元结点不存在 (空表)
（3）循环遍历链表直到尾结点

// 8.双向循环链表的整表输出
bool printDLinkList(HLinkList L)
{
	// [0] 错误处理: 头结点不存在或首元结点不存在
	if (L == NULL || L->next == L)
	{
		return false;
	}

	// [1] 初始化临时指针p指向首元结点
	DNode* p = L->next;  

	// [3] 循环遍历链表直到尾结点
	while (p != L)
	{
		printf("%d-->", p->data);
		p = p->next;
	}

	printf("end\n");
	return true;
}

9.基本操作如下：

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

typedef int ElemType;
#define bool int
#define true 1
#define false 0

//1.双向循环链表的结构定义（与双向链表完全一致）
typedef struct DNode
{
	ElemType data;// 数据域
	struct DNode* prior, * next; //前驱和后继指针
}DNode, * HLinkList;
//DNode * 用来定义结点指针
//HLinkList  用来定义链表指针


// 2. 双向循环链表的初始化操作
bool InitLinkList(HLinkList* L)
{
	// 1 为链表的头结点分配内存
	*L = (DNode*)malloc(sizeof(DNode));

	// 2 检查内存分配是否成功
	if (*L == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	// 3 初始化头结点的前驱和后继指针，指向自身，形成空的循环链表
	(*L)->next = *L;
	(*L)->prior = *L;

	// 4 返回初始化成功的标志
	return true;
}

// 3. 双向循环链表的判空操作
bool DLinkListEmpty(HLinkList L)
{
	//1 如果链表指针为空，则链表为空
	if (L == NULL)
	{
		return true;
	}

	//2 如果链表的头结点的后继和前驱指针指向自身，则链表为空
	//这里可以取其一，但是为了严谨性，取两者
	if (L->next == L&&L->prior==NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}


// 4. 双向循环链表的按位插入操作
// 由于链表是循环链表，因此终止条件不能直接使用 p != L；
// 应通过 p->next != L 来终止遍历
bool InsertDLinkList(HLinkList L, int i, ElemType e)
{
	//[0]错误处理:头结点不存在 或 i小于1
	if (L == NULL || i < 1)
	{
		return false;
	}

	//[1]初始化临时指针p指向头结点
	DNode* p = L;

	//[2]初始化计数器为0
	int j = 0;

	//[3]循环查找第i-1个结点的位置
	//p->next!=L:
		//1.保证首元结点不存在时，不进入循环
		//2.保证i大于表长时， p指向尾结点，终止循环（此时如果待插入位置为尾结点的下一个结点，这是有效的，所以i大于表长加1的情况需要特判）
	//j<i-1:
		//正常情况下，找到第i-1个结点
	while (p->next != L && j < i - 1)
	{
		p = p->next;
		j++;
	}

	//[4]异常判断
	//p->next == L && j != i - 1:
		//i大于表长加1的情况（该插入位置错误）
	if (p->next == L && j != i - 1)
	{
		return false;
	}

	//[5]建立并初始化插入结点
	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	s->data = e;

	//[6]空表尾部插入操作（注意改变头结点的prior与next域）
	// 此时 p 指向头结点，且链表为空（头结点的 next 和 prior 都指向头结点自身）
	if (p->next == L && p->prior == L)
	{
		s->prior = p;//等价于s->prior =L;
		s->next = p->next;//等价于s->next = L;
		//当前p指向空表的头结点，并不存在p->next 结点，所以直接更改头结点的prior,next域即可(为了维护循环结构的完整性)
		L->prior = s;
		L->next = s;
	}
	//[7]非空表的尾部插入或一般插入操作(与双向链表的正常插入过程一致)
	else
	{
		s->prior = p;
		s->next = p->next;//先解决待插入结点的前驱后继指向
		

		p->next->prior = s;//然后解决 待插入结点 后继结点 的前驱指向
		p->next = s;//最后解决 待插入结点 前驱结点的 后继指向      
	}
	return true;
}



// 5. 双向循环链表的按位删除操作(与双向链表的删除过程完全一致,但是注意终止条件)
bool DeleteDLinkList(HLinkList L, int i, ElemType *e)
{
	//[0]错误处理:头结点不存在 或 i小于1
	if (L == NULL || i < 1)
	{
		return false;
	}

	//[1]初始化临时指针p指向首元结点
	DNode* p = L->next;
	
	//[2]初始化计数器为1
	int j = 1;


	//[3]循环查找第i个结点的位置
	//p!=L:
		//1.保证首元结点不存在时，不进入循环
		//2.保证i大于表长时,p指向尾结点next域（L），终止循环（比如：i=表长加1：此时待删除位置是尾结点 的后面 该位置是头结点的位置）
	//j<i-1:
		//正常情况下，找到第i个结点
	while (p != L && j < i)
	{
		p = p->next;
		j++;
	}

	//[4]异常判断
	//p==L:
		//1.首元结点不存在的情况（空表）
		//2.i大于表长的情况（该删除位置为头结点）
	if (p == L)
	{
		return false;
	}

	//[5]核心：删除结点:更新前驱和后继结点的指针（只要不删除头结点就是对的）
	*e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;

	free(p);//释放待删除结点空间

	return true;
}

// 6. 双向循环链表的头插法建立
bool CreateDLinkList_H(HLinkList* L, int n)
{
	//[1]建立链表头结点并初始化next与prior域：注意指向自身
	*L = (DNode*)malloc(sizeof(DNode));

	if ((*L) == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	(*L)->next = (*L);
	(*L)->prior = (*L);

	DNode* s;

	//[2]循环插入新结点到表头
	for (int i = 0; i < n; i++)
	{
		//<1>初始化新结点
		s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL)
		{
			printf("内存分配失败！\n");
			return false;
		}

		scanf_s("%d", &s->data);

		//<2>改变指针指向(与按位插入的操作大同小异)
		//<2.1>s插入到空表表头
		if ((*L)->next == (*L) && (*L)->prior == (*L))
		{
			//如果链表为空，将新结点插入到头结点之后
			s->prior = *L;
			s->next = *L;
			(*L)->next = s;
			(*L)->prior = s;
		}
		//<2.2>s插入到非空表表头
		else
		{
			//如果链表非空，将新结点插入到头结点之后
			s->prior = (*L);
			s->next = (*L)->next;
			(*L)->next->prior = s;
			(*L)->next = s;
		}
	}

	return true;
}


// 7.双向循环链表的尾插建立
bool CreateDLinkList_T(HLinkList* L, int n)
{
	// [1] 建立链表头结点并初始化next与prior域（注意指向自身）
	*L = (DNode*)malloc(sizeof(DNode));
	if (*L == NULL)
	{
		printf("内存分配失败！\n");
		return false;
	}

	(*L)->next = (*L);  // 头结点的next指针指向自身，形成循环
	(*L)->prior = (*L); // 头结点的prior指针指向自身，形成循环

	// [2] 初始化尾指针，指向链表的头结点
	DNode* t = (*L);
	
	DNode* s; 

	// [3] 循环插入新结点到表尾
	for (int i = 0; i < n; i++)
	{
		// <1> 初始化新结点
		s = (DNode*)malloc(sizeof(DNode));  
		
		if (s == NULL)
		{
			printf("内存分配失败！\n");
			return false;
		}

		scanf_s("%d", &s->data);  


		// <2> 改变指针指向 (插入到尾部 且 不需要特判)
		//<2.1>先解决新结点的next与prior域
		s->prior = t;
		s->next = *L;//注意循环结构的完整性  
		
		//<2.2> 再解决当前尾结点的next域 并 更新尾指针指向
		//这里着重注意更新头结点的prior域，以保证循环结构的完整性
		t->next = s;   // 更新当前尾结点的next域
		(*L)->prior = s; // 更新头结点的prior域指向新结点（保证循环结构的完整性）

		t = s;  // 更新尾指针t，指向新的尾结点
	}

	return true;
}


// 8.双向循环链表的整表输出
bool printDLinkList(HLinkList L)
{
	// [0] 错误处理: 头结点不存在或首元结点不存在
	if (L == NULL || L->next == L)
	{
		return false;
	}

	// [1] 初始化临时指针p指向首元结点
	DNode* p = L->next;  

	// [3] 循环遍历链表直到尾结点
	while (p != L)
	{
		printf("%d-->", p->data);
		p = p->next;
	}

	printf("end\n");
	return true;
}


int main()
{
	HLinkList L1,L2;
	printf("头插法建立双向循环链表L1:\n");
	CreateDLinkList_H(&L1, 6);
	printf("尾插法建立双向循环链表L2:\n");
	CreateDLinkList_T(&L2, 6);
	printf("从头打印双向循环链表L1:\n");
	printDLinkList(L1);
	printf("\n");

	printf("从头打印双向循环链表L2:\n");
	printDLinkList(L2);

	printf("向L2中插入部分元素！\n");
	printf("表尾插入：\n");
	InsertDLinkList(L2, 7, 3);
	printDLinkList(L2);

	printf("表头插入：\n");
	InsertDLinkList(L2, 1, 33);
	printDLinkList(L2);

	printf("删除L2中部分元素：\n");
	ElemType e1;
	printf("删除表头元素！\n");
	DeleteDLinkList(L2, 1, &e1);
	printDLinkList(L2);


	ElemType e2;
	printf("删除表尾元素！\n");
	DeleteDLinkList(L2, 7, &e2);
	printDLinkList(L2);



	if (DLinkListEmpty(L2))
	{
		printf("L2为空表！\n");
	}
	else
	{
		printf("L2不为空表！\n");
	}
	return 0;
}

在这里插入图片描述

float_com
关注
  • 28
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
双向链表.doc循环链表的存储结构
03-21
此外，文章中还提到了一个完整的线性链表类型定义，包括带头结点的链表结构`LinkList`，以及一系列用于创建、销毁、操作链表的函数，如`MakeNode`用于动态分配节点，`FreeNode`用于释放节点，`InitLinst`用于初始化...
线性表【双向链表基本定义与操作】（带头结点）
2401_82676816的博客
08-12 585
该结点前驱元素的next域指向自己；后继元素的prior域指向自己在双向链表中有些操作(如:ListLength、GetElem，ClearList,Destroy等)，因仅涉及一个方向的指针，故它们的算法与单链表的相同。但在插入、删除时，则需同时修改两个方向上的指针，两者的操作的时间复杂度均为 O(n)。//1.双向链表的结构定义多一个指向前驱的指针域// 数据域//前驱和后继指针//DNode * 用来定义结点指针//DLinkList 用来定义链表指针。
线性表——循环链表、双向链表
m0_53359491的博客
12-07 541
目录一、循环链表1、定义和特点 2、初始化循环链表 3、求循环链表的长度4、遍历循环链表找到值为x的结点个数（重点在于遍历操作）5、循环链表的典型应用——约瑟夫环 二、双向链表1、定义和特点 2、双向链表的类型声明3、求双向循环链表的长度 4、双向循环链表插入算法5、双向循环链表删除结点算法 注：以下算法中循环链表的节点声明同单链表 3、求循环链表的长度 4、遍历循环链表找到值为x的结点个数（重点在于遍历操作） 5、循环链表的典型应用——约瑟夫环 题解代码： 运行结果
数据结构-线性表之带头结点的双向循环链表
快乐江湖的博客
01-26 1102
文章目录前言实现（1）结构定义（2）基本函数（3）操作实现测试代码 前言 链表的类型有很多种（根据带头或不带头，循环或非循环等等），但是我们重点研究的只有两种，一种结构非常简单是无头单向非循环链表，有关它的操作见 数据结构-线性表之单链表 这种结果在开发中基本不会使用，因为因为结构简单往往意味着操作复杂，比如在求职中OJ题，有关链表的基本都用的是这种结构，关于这些OJ题感兴趣的见 链表经典题 另一种则是链表中结构最为复杂的——带头结点的双向循环链表 这种结构看起来确实是很复杂的，但是它的操作很简单
数据结构线性表——带头双向循环链表
2303_78442132的博客
11-11 875
数据结构、线性表、双链表
带头结点双链循环线性表.rar_循环双链表
09-14
在“带头结点双链循环线性表”中，“头结点”是一个特殊的结点，它的存在主要是为了方便对链表进行操作，例如插入和删除元素。头结点不存储实际的数据，而是作为链表的起点，连接着链表中的第一个元素。同时，由于是...
02-第2章线性表第7讲-双向链表和双向循环链表.pdf
12-16
在带头结点的双向循环链表中，通常头结点的数据域可以不存储任何信息。双向循环链表上的算法实现可以分为三部分：链表长度算法、插入算法和删除算法。 （1）链表长度算法 链表长度算法的设计思路与单循环链表的求...
lianbiao.rar_双向链表
09-23
2. 初始化链表：程序可能会有一个函数来创建并初始化带头结点的双链循环线性表。 ```c Node* createCircularDoublyLinkedList() { Node* head = (Node*)malloc(sizeof(Node)); head->next = head->prev = head; //...
常见8种数据结构
qq_43575301的博客
08-08 2094
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 598
双向链表的创建，插入，遍历，删除
数据结构以及时间复杂度
qq_69304031的博客
08-13 302
时间复杂度，平衡二叉树，红黑树，哈夫曼树
知识改变命运 数据结构【洗牌算法(顺序表)】
2402_84062064的博客
08-13 161
a：这个类里面包括一个String类型的数据和int数据类型的数据分别存储花色和牌号b：创建一个构造方法对牌号和花色赋值·c：进行toString重写a：创造一个数组里面包含了四种花色b：利用for循环对花色与牌号结合 然后赋值给牌中。
数据结构特点
最新发布
书山有路
08-13 330
数据结构：相互之前存在一种或多种关系的数据集合 1、数组：连续的内存空间，长度在分配内存时确定。 访问时间复杂度为1，查找时间复杂度是N，插入或者删除时间复杂度为1-N，插入或者删除时间复杂度为1-N， 2，链表：非连续的内存空间。存储数据是分配内存，并将内存插入链表中。访问时间复杂度为N，插入和删除时间复杂度为1 3，堆栈：先进后出 4，队列：先进先出
C语言基础编程题：第 k 小整数（C语言版，采用冒泡排序）
我就知道你会来，我们一起进步吧！
08-13 244
现有n个正整数，要求出这 n 个正整数中的第k个最小整数(相同大小的整数只计算一次)。第一行为 n 和 k;第二行开始为 n 个正整数的值，整数间用空格隔开。n< 10000，k< 1000，正整数均小于 30000.第k个最小整数的值;若无解，则输出NO RESULT。
【数据结构】顺序表
2302_81044676的博客
08-10 284
关于顺序表的知识以及realloc的用法详解
「栈」实现LIFO栈（先进后出栈|堆栈|stack）的功能 / 手撕数据结构（C++）
dakingffo的博客
08-09 957
​栈，是一种基本的数据结构，也是一种数据适配器。它在底层上以链表方法或动态数组方法实现。本文选择了使用动态数组来实现这种数据结构。
数据结构--双指针与LeetCodeHOT100
wumingzei的博客
08-09 922
在编程和算法设计中，双指针技术是一种常用且强大的工具。它涉及使用两个指针在数据结构上进行操作，以解决特定的问题。双指针技术常见于数组、链表、字符串等数据结构的处理中，尤其在处理需要在数据集合中进行遍历、搜索和排序的场景时表现出色。双指针是一种算法策略，它使用两个游标（或索引）来遍历或操作数据结构中的元素。这两个指针可以以不同的速度移动，或者从不同的起点开始，以实现不同的算法目标。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值