数据结构笔记（六）-- 双向链表

最新推荐文章于 2024-07-25 09:47:49 发布
最新推荐文章于 2024-07-25 09:47:49 发布
阅读量524 收藏 4
点赞数 1
文章标签： 链表 指针 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43609475/article/details/106421397
版权

带头结点的双向循环链表的实现

一、双向链表的概念

双向链表的每个结点有两个指针，一个指针指向该结点的前驱，一个指针指向该结点的后继。

二、双向链表的存储结构

在这里插入图片描述

//线性表的双向链表存储结构
typedef struct DuLNode
{
	ElemType data;
	DuLNode *prior, *next;
}DuLNode, *DuLinkList;

三、带有头结点的双向循环链表的样子

在这里插入图片描述

四、带头结点的双向循环链表的操作

五、操作的实现

1、 创建空的双向循环链表L

在这里插入图片描述

void InitList(DuLinkList &L)
{ // 产生空的双向循环链表L
	L = (DuLinkList)malloc(sizeof(DuLNode));//创建结点
	if (L != NULL)
		L->next = L->prior = L;
	else
		exit(-1);
}

2、判断双循环链表是否为空

在这里插入图片描述

bool ListEmpty(DuLinkList L)
{ // 初始条件：线性表L已存在。
  //操作结果：若L为空表，则返回true，否则返回false
	if (L->next == L && L->prior == L)
		return true;
	else
		return false;
}

3、获取双循环链表的结点元素个数

int ListLength(DuLinkList L)
{ // 初始条件：L已存在。操作结果：返回L中数据元素个数
	//只利用后指针域即可
	int i = 0;
	DuLinkList p = L->next; // p指向第一个结点
	while (p != L) // 查看p是不是指向头结点，不是头结点就计数1
	{
		i++;
		p = p->next;
	}
	return i;
}

4、在带头结点的双链循环线性表L中第i个位置之前插入元素e

在这里插入图片描述

bool ListInsert(DuLinkList L, int i, ElemType e)
{ // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
	DuLinkList p = L, NewNode;
	if (i<1 || i>ListLength(L) + 1) // i超出范围，其值不合法
		return false;
	int j = 0;
	while (j < i - 1)// 在L中确定第i-1个结点的位置指针p
	{
		j++;
		p = p->next;
	}
	if (p == NULL) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
		return false;
	NewNode = (DuLinkList)malloc(sizeof(DuLNode));
	if (NewNode == NULL)
		return false;
	NewNode->data = e;//新节点赋值
	NewNode->prior = p; // 新结点前指针域指向第i-1个结点
	NewNode->next = p->next;//新结点后指针域指向第i个结点
	p->next->prior = NewNode;//第i个结点的前指针域指向新结点
	p->next = NewNode;//第i-1个结点的后指针域指向新结点
	return true;
}

5、遍历输出结点值

void ListTraverse(DuLinkList L)
{
	
	DuLinkList p = L->next;//p指向第一个结点
	while (p != L)
	{
		printf("  %d",p->data);
		p = p->next;
	}
	printf("\n");
}

6、获取第i个结点的值

ElemType GetElem(DuLinkList L, ElemType i)
{
	if (i<1||i>ListLength(L))//i不在链表结点范围之内
	{
		printf("输入的i值非法");
		return false;
	}

	DuLinkList p = L;
	int j = 0;
	while (j<i)//找到第i个结点的指针
	{
		j++;
		p = p->next;
	}
	return p->data;//返回地i和结点的值
}

7、反向遍历输出结点值

void ListTraverseBack(DuLinkList L)
{
	DuLinkList p = L->prior;//p指向第一个结点
	while (p != L)
	{
		printf("  %d", p->data);
		p = p->prior;
	}
	printf("\n");
}

8、 查询结点值为cur_e的结点的直接前驱结点值

bool PriorElem(DuLinkList L, ElemType cur_e, ElemType &pre_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
  //           否则操作失败，pre_e无定义
	DuLinkList q = NULL, p = L; // p指向头结点
	if (p->next->data == cur_e)//判断cur_e是否等于首结点值
	{
		printf("首结点没有前驱");
		return false;// 操作失败
	}
	while (p->next != L) // p的下一个结点不是头结点则指向下一个结点
	{	
		p = p->next;
		if (p->data == cur_e)//判后
		{
			pre_e = p->prior->data;
			return true;
		}
	}
	return false; // 操作失败
}

9、 查询结点值为cur_e的结点的直接后驱结点值

bool NextElem(DuLinkList L, ElemType cur_e, ElemType &next_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           否则操作失败，next_e无定义
	DuLinkList p = L->next; // p指向首结点
	while (p->next != L) // p指向结点的指针域没有指向头结点（p的下一个结点不是头结点），只有最后一个结点的指针域指向头结点，即p不指向最后一个结点
	{
		if (p->data == cur_e)//判前
		{
			next_e = p->next->data;//满足条件获取后继结点值
			return true;
		}
		p = p->next;//不满足条件p指向下一个结点
	}
	return false; // 操作失败
}

10、双向链表L中返回第i个元素的地址。

DuLinkList GetElemP(DuLinkList L, int i) // 另加
{ // 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，
  // 返回NULL
	int j;
	DuLinkList p = L; // p指向头结点
	if (i<0 || i>ListLength(L)) // i值不合法
		return NULL;
	for (j = 1; j <= i; j++)
		p = p->next;
	return p;
}

11、删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长

在这里插入图片描述

bool ListDelete(DuLinkList L,int i,ElemType &e)
{
	if (i<1 || i>ListLength(L))
	{
		printf("i的值不合法\n");
		return false;
	}
	DuLinkList p = L,q;
	int j = 0;
	while (j < i-1)//找到第i-1个结点
	{
		j++;
		p = p->next;
	}
	q = p->next;
	e = q->data;
	p->next = q->next;
	q->next->prior = p;
	free(q);
	return true;
}

12、清空双循环链表

void ClearList(DuLinkList L) // 不改变L
{ // 初始条件：L已存在。操作结果：将L重置为空表
	DuLinkList q, p = L->next; // p指向第一个结点
	while (p != L) // p没到表头
	{
		q = p->next;
		free(p);
		p = q;
	}
	L->next = L->prior = L; // 头结点的两个指针域均指向自身
}

13、销毁双循环链表

void DestroyList(DuLinkList &L)
{ // 操作结果：销毁双向循环链表L
	DuLinkList q, p = L->next; // p指向第一个结点
	while (p != L) // p没到表头
	{
		q = p->next;
		free(p);
		p = q;
	}
	free(L);
	L = NULL;
}

最后给出完整代码

// 带头结点的双向循环链表.cpp

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

//定义数据类型;
typedef int ElemType;

//线性表的双向链表存储结构
typedef struct DuLNode
{
	ElemType data;
	DuLNode *prior, *next;
}DuLNode, *DuLinkList;

//函数声明
//1、 创建双向循环链表L
void InitList(DuLinkList &L);
//2、判断双循环链表是否为空
bool ListEmpty(DuLinkList L);
//3、获取双循环链表的结点元素个数
int ListLength(DuLinkList L);
//4、在带头结点的双链循环线性表L中第i个位置之前插入元素e
bool ListInsert(DuLinkList L, int i, ElemType e);
//5、遍历输出结点值
void ListTraverse(DuLinkList L);
//6、获取第i个结点的值
ElemType GetElem(DuLinkList L, ElemType i);
//7、反向遍历输出结点值
void ListTraverseBack(DuLinkList L);
//8、 查询结点值为cur_e的结点的直接前驱结点值
bool PriorElem(DuLinkList L, ElemType cur_e, ElemType &pre_e);
//9、 查询结点值为cur_e的结点的直接后驱结点值
bool NextElem(DuLinkList L, ElemType cur_e, ElemType &next_e);
//10、双向链表L中返回第i个元素的地址。
DuLinkList GetElemP(DuLinkList L, int i);
//11、删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
bool ListDelete(DuLinkList L, int i, ElemType &e);
//12、清空双循环链表
void ClearList(DuLinkList L);// 不改变L


int main()
{
	DuLinkList L;
	InitList(L);
	if (ListEmpty(L))
	{
		printf("链表为空！\n");
	}
	else
	{
		printf("链表不为空\n");
	}
	printf("链表的长度为 %d\n",ListLength(L));
	for (int i = 1; i <= 10; i++)
	{
		ListInsert(L,i,2*i);
	}
	ListTraverse(L);
	int i = 10;
	printf("获取第%d个结点值为 %d\n", i,GetElem(L, i));
	ListTraverseBack(L);
	DuLinkList p = GetElemP(L,  i);
	printf("第%d个结点的地址是%p\n",i,p);
	ElemType e = 0;
	ListDelete( L,  i, e);
	printf("删除的第%d个结点的值是%d\n",i,e);
	ClearList(L);
	ListTraverse(L);
	//DestroyList(L);
	//ListTraverse(L);


	return 0;
}
//1、 创建双向循环链表L
void InitList(DuLinkList &L)
{ // 产生空的双向循环链表L
	L = (DuLinkList)malloc(sizeof(DuLNode));//创建结点
	if (L != NULL)
		L->next = L->prior = L;
	else
		exit(-1);
}

//2、判断双循环链表是否为空
bool ListEmpty(DuLinkList L)
{ // 初始条件：线性表L已存在。
  //操作结果：若L为空表，则返回true，否则返回false
	if (L->next == L && L->prior == L)
		return true;
	else
		return false;
}
//3、获取双循环链表的结点元素个数
int ListLength(DuLinkList L)
{ // 初始条件：L已存在。操作结果：返回L中数据元素个数
	//只利用后指针域即可
	int i = 0;
	DuLinkList p = L->next; // p指向第一个结点
	while (p != L) // 查看p是不是指向头结点，不是头结点就计数1
	{
		i++;
		p = p->next;
	}
	return i;
}


// 4、在带头结点的双链循环线性表L中第i个位置之前插入元素e
bool ListInsert(DuLinkList L, int i, ElemType e)
{ // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
  // 改进算法2.18，否则无法在第表长+1个结点之前插入元素
	DuLinkList p = L, NewNode;
	if (i<1 || i>ListLength(L) + 1) // i超出范围，其值不合法
		return false;
	int j = 0;
	while (j < i - 1)// 在L中确定第i-1个结点的位置指针p
	{
		j++;
		p = p->next;
	}
	if (p == NULL) // p=NULL,即第i个元素的前驱不存在(设头结点为第1个元素的前驱)
		return false;
	NewNode = (DuLinkList)malloc(sizeof(DuLNode));
	if (NewNode == NULL)
		return false;
	NewNode->data = e;//新节点赋值
	NewNode->prior = p; // 新结点前指针域指向第i-1个结点
	NewNode->next = p->next;//新结点后指针域指向第i个结点
	p->next->prior = NewNode;//第i个结点的前指针域指向新结点
	p->next = NewNode;//第i-1个结点的后指针域指向新结点
	return true;
}
//5、遍历输出结点值
void ListTraverse(DuLinkList L)
{
	
	DuLinkList p = L->next;//p指向第一个结点
	while (p != L)
	{
		printf("  %d",p->data);
		p = p->next;
	}
	printf("\n");
}
//6、获取第i个结点的值
ElemType GetElem(DuLinkList L, ElemType i)
{
	if (i<1||i>ListLength(L))//i不在链表结点范围之内
	{
		printf("输入的i值非法");
		return false;
	}

	DuLinkList p = L;
	int j = 0;
	while (j<i)//找到第i个结点的指针
	{
		j++;
		p = p->next;
	}
	return p->data;//返回地i和结点的值
}

//7、反向遍历输出结点值
void ListTraverseBack(DuLinkList L)
{
	DuLinkList p = L->prior;//p指向第一个结点
	while (p != L)
	{
		printf("  %d", p->data);
		p = p->prior;
	}
	printf("\n");
}

//8、 查询结点值为cur_e的结点的直接前驱结点值
bool PriorElem(DuLinkList L, ElemType cur_e, ElemType &pre_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
  //           否则操作失败，pre_e无定义
	DuLinkList q = NULL, p = L; // p指向头结点
	if (p->next->data == cur_e)//判断cur_e是否等于首结点值
	{
		printf("首结点没有前驱");
		return false;// 操作失败
	}
	while (p->next != L) // p的下一个结点不是头结点则指向下一个结点
	{	
		p = p->next;
		if (p->data == cur_e)//判后
		{
			pre_e = p->prior->data;
			return true;
		}
	}
	return false; // 操作失败
}

//9、 查询结点值为cur_e的结点的直接后驱结点值
bool NextElem(DuLinkList L, ElemType cur_e, ElemType &next_e)
{ // 初始条件：线性表L已存在
  // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
  //           否则操作失败，next_e无定义
	DuLinkList p = L->next; // p指向首结点
	while (p->next != L) // p指向结点的指针域没有指向头结点（p的下一个结点不是头结点），只有最后一个结点的指针域指向头结点，即p不指向最后一个结点
	{
		if (p->data == cur_e)//判前
		{
			next_e = p->next->data;//满足条件获取后继结点值
			return true;
		}
		p = p->next;//不满足条件p指向下一个结点
	}
	return false; // 操作失败
}
//10、双向链表L中返回第i个元素的地址。
DuLinkList GetElemP(DuLinkList L, int i) // 另加
{ // 在双向链表L中返回第i个元素的地址。i为0，返回头结点的地址。若第i个元素不存在，
  // 返回NULL
	int j;
	DuLinkList p = L; // p指向头结点
	if (i<0 || i>ListLength(L)) // i值不合法
		return NULL;
	for (j = 1; j <= i; j++)
		p = p->next;
	return p;
}
//11、删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
bool ListDelete(DuLinkList L,int i,ElemType &e)
{
	if (i<1 || i>ListLength(L))
	{
		printf("i的值不合法\n");
		return false;
	}
	DuLinkList p = L,q;
	int j = 0;
	while (j < i-1)//找到第i-1个结点
	{
		j++;
		p = p->next;
	}
	q = p->next;
	e = q->data;
	p->next = q->next;
	q->next->prior = p;
	free(q);
	return true;
}
//12、清空双循环链表
void ClearList(DuLinkList L) // 不改变L
{ // 初始条件：L已存在。操作结果：将L重置为空表
	DuLinkList q, p = L->next; // p指向第一个结点
	while (p != L) // p没到表头
	{
		q = p->next;
		free(p);
		p = q;
	}
	L->next = L->prior = L; // 头结点的两个指针域均指向自身
}
//13、销毁双循环链表
void DestroyList(DuLinkList &L)
{ // 操作结果：销毁双向循环链表L
	DuLinkList q, p = L->next; // p指向第一个结点
	while (p != L) // p没到表头
	{
		q = p->next;
		free(p);
		p = q;
	}
	free(L);
	L = NULL;
}
淡定的炮仗
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构实验--双向链表及其应用
m0_46679726的博客
01-12 3215
学习笔记--数据结构前言数据结构实验一：实验要求：二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 很早就有 想写博客的想法，但是一直都没有落实起
数据结构-带头双向链表笔记
Night_dreams的博客
05-11 138
双向带头循环链表，它包含一个不存储数据只存储头节点地址的哨兵位，还有每个节点会像单链表一样存储下一个节点的地址，并且还会存储上一个节点的地址，能够通过上一个地址而找到上一个节点，这种结构对于数据的增添或删除的实现是非常简单的。我们都知道，单链表每个内存块只存储下一个节点地址，想要找到前一个数据很麻烦，要另记录前一个数据地址，像是尾插更是要遍历一遍链表才能，这样某些场景时间复杂度和空间复杂都不小。，一般用在单独存储数据。拥有前一个节点地址，可以直接插入数据，不需要分情况以及判空，就可以很容易实现。
Java数据结构与算法——双向链表
★★光亭★★
03-11 6109
Java数据结构与算法——双向链表
数据结构--双向链表（图文）
SouTY_C的博客
06-26 977
双向链表相较于单链表的优势在于可以快速访问和操作节点的相邻元素，尤其在需要频繁插入或删除元素的场景中，它提供了更高效的数据操作方式。双向链表常用于实现高级数据结构，如栈、队列、列表等，并且在某些编程语言的标准库中，如C++的STL和Java的LinkedList，都提供了双向链表的实现。双向链表在每个节点处都维护了两个指针，一个指向前一个节点（称为前驱节点），另一个指向下一个节点（称为后继节点）。：头节点的后继指针指向尾节点，尾节点的前驱指针又指回头节点，这样的双向链表形成一个环。情况一：链表只有头节点。
数据结构-循环链表和双向链表
pyc68的博客
06-29 702
本篇文章介绍数据结构中的循环链表和双向链表
《数据结构学习笔记---第四篇》---带头双向循环链表具体实现
yl1509797225的博客
03-25 419
带头双向循环链表
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Python----数据结构----链表----双向链表
一盏偏灯的博客
03-01 112
Python学习之路，点击有全套Python笔记 双向链表 一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 步骤： is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item...
数据结构-带头双向循环链表
2302_79539362的博客
12-02 2666
数据结构-带头双向循环链表
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 22万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
数据结构学习笔记-链表中的双向链表（JAVA）
08-10
综上所述，双向链表是数据结构中的一个重要组成部分，它提供了对链表的双向访问能力，使得在链表操作上的灵活性大大提高。在Java中实现双向链表，需要理解其基本结构和操作方法，并能编写相应的代码来创建、修改和...
算法数据结构学习笔记-C语言.zip
01-01
链表分为单链表（每个节点只有一个指针）和双向链表（每个节点有两个指针，分别指向前后节点）。 3. 栈：栈是一种后进先出（LIFO）的数据结构，常用的操作是压栈（入栈，添加元素到栈顶）和弹栈（出栈，移除栈顶...
笔记-数据结构.docx
08-07
数据结构笔记 数据结构是一门基础学科，它是计算机科学和技术的核心组成部分。数据结构是指在计算机中存储、组织和管理数据的方式，它是计算机程序设计和算法实现的基础。 一、 线性表 线性表是数据结构的基本...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
buaa数据结构期末tention-model-for-netw笔记
06-24
在“buaa数据结构期末tention-model-for-netw笔记”中，我们可以推测这是北京航空航天大学（简称BUAU）数据结构课程期末复习或考试的相关资料，其中可能包含了对网络（可能是指网络数据或者网络安全）应用的数据结构...
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1600
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
打卡第22天------回溯算法
GodLoveMe的博客
07-24 713
开始学习了，希望我可以尽快成功上岸！
【算法】二进制常用操作
最新发布
2301_79728896的博客
07-25 410
n>>k&1​lowbit(x)的用法:返回x中最后一个1，lowbitxx−x​。
labuladong刷题笔记V1.31：算法精华与数据结构详解
"labuladong的刷题笔记V1.31"是一份全面的IT学习资料，专注于数据结构和算法的讲解与练习。该笔记涵盖了多个章节，从基础数据结构如数组、链表、滑动窗口、前缀和、差分数组，到更进阶的数据结构如二叉树、队列/栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值