带头带环双向链表的实现及其相关操作。。

最新推荐文章于 2018-06-01 23:41:25 发布
最新推荐文章于 2018-06-01 23:41:25 发布
阅读量189 收藏
点赞数
分类专栏： 数据结构 文章标签： DLinkList Add Delete Update Find
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GangStudyIT/article/details/79306329
版权

    在前面博客中我们讲到关于线性表中的单链表，我们实现了不带头不带环的单项链表，

在链表中不带头不带环的单链表是相对比其他链表要麻烦，且应用相对较少。那么今天

我们来实现带头带环的双向链表，带头带环双向链表相应用比较多，应为它比较简介，相关的操作

相对简单。

    那么我们来看一下声明：

#pragma once

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

#define FUNCTIONNAME printf("\n================%s=============\n",__FUNCTION__)

typedef char LinkType;

typedef struct DLinkNode{
	LinkType data;
	struct DLinkNode *prev;
	struct DLinkNode *next;
}DLinkNode;

// 初始化链表。
void DLinkNodeInit(DLinkNode *head);

// 尾插一个元素。
void DLninkNodePushBack(DLinkNode *head, LinkType value);

// 尾删一个元素。
void DLinkNodePopBack(DLinkNode *head);

// 头插入一个元素。
void DLinkNodePushFront(DLinkNode *head, LinkType value);

// 头删一个元素。
void DLinkNodePopFront(DLinkNode *head);

// 查找指定元素。
DLinkNode* DLinkNodeFind(DLinkNode *head, LinkType find);

// 在指定位置之前插入一个元素。
void DLinkNodeInsertFront(DLinkNode *pos, LinkType value);

// 在指定元素之后插入一个元素。
void DLinkNodeInsertBack(DLinkNode *pos, LinkType value);

// 删除指定位置的节点。
void DLinkNodeErase(DLinkNode *head,DLinkNode *pos);

// 删除指定元素的第一个节点。
void DLinkNodeRemove(DLinkNode *head, LinkType value);

// 删除指定元素的所有节点。
void DLinkNodeRemoveAll(DLinkNode *head, LinkType value);

// 求链表的长度
size_t DLinkNodeSize(DLinkNode *head);

// 判读链表是否为空。
int DLinkNodeEmpty(DLinkNode *head);

声明的相关函数实现：

相关单元测试：

#include "DLinkNode.h"

void DLinkNodePrint(DLinkNode *head)
{
	if (head == NULL)
	{
		return;
	}
	DLinkNode *cur = head->next;
	printf("head->");
	for (;cur != head;cur = cur->next)
	{
		printf("[%c %p]->",cur->data,cur);
	}
	printf("head\n");
}

// 初始化链表。
void DLinkNodeInit(DLinkNode *head)
{
	if (head == NULL)
	{
		// 非法输入
		return;
	}
	head->next = head;
	head->prev = head;
}

// 创建节点
DLinkNode *CreatNode(LinkType value)
{
	DLinkNode *node = (DLinkNode*)malloc(sizeof(DLinkNode));
	if (node == NULL)
	{
		// 开辟空间失败。
		return;
	}
	node->data = value;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

// 尾插一个元素。
DLinkNode *DLinkNodePushBack(DLinkNode *head, LinkType value)
{
	if (head == NULL)
	{
		// 非法输入。
		return NULL;
	}
	DLinkNode *new_node = CreatNode(value);
	DLinkNode *pre = head->prev;
	pre->next = new_node;
	new_node->prev = pre;

	new_node->next = head;
	head->prev = new_node;
	return new_node;
}

// 尾删一个元素。
void DLinkNodePopBack(DLinkNode *head)
{
	if (head == NULL)
{
		// 非法输入。
		return;
	}
	if (head->next == head)
	{
		// 空链表。
		return;
	}
	DLinkNode *delete = head->prev;
	DLinkNode *pre = delete->prev;
	pre->next = head;
	head->prev = pre;
	free(delete);
}

// 头插入一个元素。
void DLinkNodePushFront(DLinkNode *head, LinkType value)
{
	if (head == NULL)
	{
		return;
	}
	DLinkNode *new_node = CreatNode(value);
	DLinkNode *next = head->next;
	head->next = new_node;
	new_node->prev = head;
	
	next->prev = new_node;
	new_node->next = next;
}

// 头删一个元素。
void DLinkNodePopFront(DLinkNode *head)
{
	if (head == NULL)
	{
		// 非法输入。
		return;
	}
	if (head->next == head)
	{
		// 链表为空。
		return;
	}
	DLinkNode *delete = head->next;
	DLinkNode *next = delete->next;
	head->next = next;
	next->prev = head;
	free(delete);
}

// 查找指定元素。
DLinkNode* DLinkNodeFind(DLinkNode *head, LinkType find)
{
	if (head == NULL || head->next == head)
	{
		// 链表为空或者非法输入。
		return NULL;
	}
	DLinkNode *cur = head->next;
	while (cur != head)
	{
		if (cur->data == find)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 在指定位置之前插入一个元素。
void DLinkNodeInsertFront(DLinkNode *pos, LinkType value)
{
	if (pos == NULL)
	{
		// 非法输入。
		return;
	}
	DLinkNode *new_node = CreatNode(value);
	DLinkNode *prev = pos->prev;
	prev->next = new_node;
	new_node->prev = prev;

	new_node->next = pos;
	pos->prev = new_node;
}


// 在指定元素之后插入一个元素。
void DLinkNodeInsertBack(DLinkNode *pos, LinkType value)
{
	if (pos == NULL)
	{
		// 非法输入。
		return;
	}
	DLinkNode *new_node = CreatNode(value);
	DLinkNode *next = pos->next;
	pos->next = new_node;
	new_node->prev = pos;

	new_node->next = next;
	next->prev = new_node;
}

// 删除指定位置的节点。
void DLinkNodeErase(DLinkNode *head,DLinkNode *pos)
{
	if (pos == NULL)
	{
		// 非法输入。
		return;
	}
	DLinkNode *cur = head->next;
	while (cur != head)
	{
		if (cur == pos)
		{
			DLinkNode *prev = pos->prev;
			DLinkNode *next = pos->next;
			prev->next = next;
			next->prev = prev;
			free(pos);
			return;
		}
		cur = cur->next;
	}
	printf("pos位置有误\n");
	return;
}


// 删除指定元素的第一个节点。
void DLinkNodeRemove(DLinkNode *head, LinkType value)
{
	if (head  == NULL)
	{
		// 非法输入。
		return;
	}
	DLinkNode *cur = head->next;
	while (cur != head)
	{
		if (cur->data == value)
		{
			DLinkNode *prev = cur->prev;
			DLinkNode *next = cur->next;
			prev->next = next;
			next->prev = prev;
		}
		cur = cur->next;
	}
}

// 删除指定元素的所有节点。
void DLinkNodeRemoveAll(DLinkNode *head, LinkType value)
{
	if (head == NULL)
	{
		return;
	}
	DLinkNode *pos;// = DLinkNodeFind(head,value);
	while (pos != NULL)
	{
		pos = DLinkNodeFind(head,value);
		DLinkNodeErase(head,pos);
	}
	return;
}


// 求链表的长度
size_t DLinkNodeSize(DLinkNode *head)
{
	if (head == NULL)
	{
		return (size_t)-1;
	}
	DLinkNode *cur = head->next;
	size_t count = 0;
	while (cur != head)
	{
		++count;
		cur = cur->next;
	}
	return count;
}

// 判读链表是否为空。
int DLinkNodeEmpty(DLinkNode *head)
{
	if (head == NULL)
	{
		return (size_t)-1;
	}
	if (head->next = head)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

///
//以下是测试代码
///

// 初始化。
void TestDLinkNodeInit()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
}

// 尾插。
void TestDLinkNodePushBack()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNodePrint(&head);
}

// 尾删。
void TestDLinkNodePopBack()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNodePrint(&head);
	DLinkNodePopBack(&head);
	DLinkNodePopBack(&head);
	DLinkNodePopBack(&head);
	DLinkNodePrint(&head);
	DLinkNodePopBack(&head);
	DLinkNodePopBack(&head);
	DLinkNodePrint(&head);
}

// 头插。
void TestDLinknodePushFront()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNodePushFront(&head,'a');
	DLinkNodePushFront(&head,'b');
	DLinkNodePrint(&head);
	DLinkNodePushFront(&head,'d');
	DLinkNodePrint(&head);
}

// 头删。
void TestDLinkNodePopFront()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNodePushFront(&head,'a');
	DLinkNodePushFront(&head,'b');
	DLinkNodePushFront(&head,'d');
	DLinkNodePrint(&head);
	DLinkNodePopFront(&head);
	DLinkNodePrint(&head);
	DLinkNodePopFront(&head);
	DLinkNodePopFront(&head);
	DLinkNodePrint(&head);
	DLinkNodePopFront(&head);
	DLinkNodePrint(&head);
}

// 按元素查找的位置。
void TestDLinkNodeFind()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNodePushFront(&head,'a');
	DLinkNode *pos = DLinkNodePushBack(&head,'b');
	DLinkNodePushFront(&head,'c');
	DLinkNodePushFront(&head,'d');
	DLinkNodePushFront(&head,'e');
	DLinkNodePrint(&head);
	DLinkNode *ret = DLinkNodeFind(&head, 'b');
	printf("except %p actual %p \n",pos, ret);
}

// 指定位置之前插入一个元素。
void TestDLinkNodeInsertFront()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNode *pos = DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNodePushBack(&head,'e');
	DLinkNodePrint(&head);
	DLinkNodeInsertFront(pos,'f');
	DLinkNodePrint(&head);
	DLinkNodeInsertFront(pos1,'g');
	DLinkNodePrint(&head);
}

// 指定位置之后插入一个元素。
void TestDLinkNodeInsertBack()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNode *pos = DLinkNodePushBack(&head,'e');
	DLinkNodePrint(&head);
	DLinkNodeInsertBack(pos1,'f');
	DLinkNodeInsertBack(pos,'g');
	DLinkNodePrint(&head);
}

// 删除指定位置节点。
void TestDLinkNodeErase()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNode *pos = DLinkNodePushBack(&head,'e');
	DLinkNodePrint(&head);
	DLinkNodeErase(&head,pos1);
	DLinkNodePrint(&head);
	DLinkNodeErase(&head,pos);
	DLinkNodePrint(&head);
}

// 删除指定元素的第一个节点。
void TestDLinkNodeRemove()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNode *pos = DLinkNodePushBack(&head,'e');
	DLinkNodePrint(&head);
	DLinkNodeRemove(&head,'b');
	DLinkNodePrint(&head);
	DLinkNodeRemove(&head,'a');
	DLinkNodePrint(&head);
}

// 删除指定元素的所有节点。
void TestDLinkNodeRemoveAll()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNode *pos = DLinkNodePushBack(&head,'c');
	DLinkNodePrint(&head);
	DLinkNodeRemoveAll(&head,'a');
	DLinkNodePrint(&head);
	DLinkNodeRemoveAll(&head,'c');
	DLinkNodePrint(&head);
}

// 判断链表是否为空，不为空求出链表的长度。
void TestDLinkNodeSize()
{
	FUNCTIONNAME;
	DLinkNode head;
	DLinkNodeInit(&head);
	int ret = DLinkNodeEmpty(&head);
	DLinkNode *pos1 = DLinkNodePushBack(&head,'a');
	DLinkNodePushBack(&head,'b');
	DLinkNodePushBack(&head,'c');
	DLinkNodePushBack(&head,'d');
	DLinkNode *pos = DLinkNodePushBack(&head,'c');
	DLinkNodePrint(&head);
	size_t size = DLinkNodeSize(&head);
	printf("except 1 actual %d\n",ret);
	printf("except 5 actual %d\n",size);
}

int main()
{
	TestDLinkNodeInit();
	TestDLinkNodePushBack();
	TestDLinkNodePopBack();
	TestDLinknodePushFront();
	TestDLinkNodePopFront();
	TestDLinkNodeFind();
	TestDLinkNodeInsertFront();
	TestDLinkNodeInsertBack();
	TestDLinkNodeErase();
	TestDLinkNodeRemove();
	TestDLinkNodeRemoveAll();
	TestDLinkNodeSize();
	return 0;
}

如有问题请多多指教。

GangStudyIT
关注
专栏目录
CList.zip_CList_C语言实现vector_链表 c语言
09-22
双向链表可以在正向和反向两个方向进行查找，提高了查找效率。 5. 更新元素：定位到指定位置的节点，然后修改其数据部分。 6. 遍历打印：从头节点开始，沿着指针遍历所有节点并打印其数据。 7. 计算大小：统计...
数据结构之双向链表(带环,带头节点)
lengxinxuexic的博客
05-07 153
#pragma once #include&lt;stddef.h&gt; #include&lt;stdio.h &gt; typedef char LinkType; typedef struct LinkNode{ LinkType data; struct LinkNode*next; }LinkNode; void LinkListInit(LinkNode** head); vo...
循环链表和双向链表PPT学习教案.pptx
10-02
循环链表和双向链表是数据结构中的重要概念，它们都是线性表的变体，主要用在存储和操作顺序关系的数据序列。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素之前增加一个特殊的结点，即头结点。头...
双向起泡排序法 双向链表 排序
06-05
本篇文章将详细探讨双向起泡排序法及其在带头结点的双向链表中的应用。 首先，我们需要了解双向链表的基础知识。双向链表是一种数据结构，每个节点包含两个指针，一个指向其前一个节点，另一个指向其后一个节点。与...
带头结点双链循环线性表.rar_循环双链表
09-14
循环双链表是一种高效的数据结构，它在单链表的基础上扩展了双向链接的功能，并形成了一个首尾相连的环形结构。这种数据结构在程序设计中非常常见，特别是在处理线性序列的问题时，如动态内存分配、文件系统管理等...
双向链表详细分析（很有用）
04-09
通过上述介绍，我们可以了解到双向链表的基本概念、节点结构、形式描述及其基本操作。这些知识点对于理解双向链表的工作原理及其应用场景至关重要。希望读者能够深入掌握这些知识点，并在实际编程中灵活运用双向链表...
数据结构中队列的实现（基于顺序表循环队列）
GangStudyIT的博客
02-25 1519
    在学习数据结构中，队列也是一个重要的数据结构，我们今天来用基于顺序表的队列（Queue），在基于顺序表队列如果是不循环的顺序表，则在出队列时，时间复杂度是O（n），所以我们用循环队列来实现，怎么解释基于循环顺序表的队列呢？我们上图： 上图是在不循环顺序表中出队。这样不难看出时间复杂度不是很好。所以我们来顺序循环队列，把顺序表让它循环利用。看图上图就是顺序表循环队列，a就是队首，d就是队尾，...
海量数据处理
GangStudyIT的博客
03-19 1197
海量数据处理 我们这里的海量数据处理主要是通过几个实际问题，应用数据结构，来熟悉哈希数据结构，位图数据结构，和布隆过滤器。如果哈希数据结构，位图数据结构和布隆过滤器 请点击[https://github.com/jacksparrowwang/cg19.github.com/tree/master/Data%20Structure](github) 海量数据的处理问题，遇到的问题一般有文件过...
对链式队列的实现（C语言）
GangStudyIT的博客
03-17 1133
对链式队列的实现 实现的具体过程： 结构体定义和函数声明 队列的初始化 队列的尾插入 取队首元素 删除队首元素 判断队列是否为空 求队列元素的个数 队列的销毁 单元测试代码 结构体定义内容和函数声明 链式队列需要定义两个指针分别来表示队头和队尾，我们用head表示头指针tail表示尾指针，这是队列的结构体，而队列的节点也是一个结构体，其实和链表的结构体特别想象，一个数据data和一...
数据结构中的堆的实现和堆排序
GangStudyIT的博客
06-01 817
堆的实现 堆的本质是一二叉树，并且是一颗完全二叉树。 堆分为大堆和小堆，大堆就是在堆顶的元素的值是这个完全二叉树中的最大值，小堆刚好相反，是最小值。在树这个数据结构定义的时候是递归定义的所以也就满足，一个树中子数的更节点是最大或者最小（取决与建立大堆还是小堆）。 堆的建立 堆的建立过程是一个进行比较的过程，也就是说，每次插入一个元素，就需要对堆进行调整，怎么调整？当然在插入的时候，我们...
对栈的实现（顺序栈和链式栈）C语言
GangStudyIT的博客
03-17 582
栈的实现 两种方法实现： 顺序栈 :基于静态顺序表 链式栈 :基于链表 顺序栈 函数的结构体和声明 基于顺序表的栈，也就是用数组的增删查改 我们看结构体和声明 typedef char SeqType; typedef struct SeqStack{ size_t size; SeqType data[MAXREPOSITORY]; }SeqStack; ...
动态顺序表的实现和增删操作。
GangStudyIT的博客
02-08 481
 对与线性表中的顺序表，有静态顺序表，和动态顺序表。关于静态顺序表的实现以及一些操作，在本博客内有相关内容，那么就不过多介绍，动态顺序表基本与静态顺序表的一些操作一样，比如，查找，删除等，不一样的就是增加，销毁，最重要的静态顺序表是建立在栈上的，而动态顺序表是建立在堆上。 那么我们就在静态的基础上与动态结合加以练习，主要体现在增加，销毁，和结构体建立上不同。那么我们来看代码。先是头文件及其声明：#...
数据结构中静态顺序表的实现和增删查改。。。
GangStudyIT的博客
12-08 439
静态顺序表是把大小已经分配好，顺序表是利用数组，实现增删查改。 首先我们要声明一个结构体，定义一个数组，它的总大小 ，还有一个用来计数它实际的大小。 我们来看代码。 先看头文件的声明： #pragma once #include #define sequence_table_max_length 100 #define TYPECHAR char #define SHOWTYPE "%c"
二叉树实现及相关操作知识梳理
GangStudyIT的博客
04-20 401
树型结构 前言 树型结构在生活中是非常常见的一种结构，应用范围很广，就用一个简单的例子来说。计算机中的文件目录就是一个树型结构，一般创建一个文件，如果文件中没有文件那么就相当于一个空树，如果里面有文件，就相当于这个文件的子树，以此类推，就形成了树型结构的文件目录。 在学习中我们主要学习二叉树的一些特性，把树细化学习。 二叉树的概念 二叉树是结点的有限集合，该集合或者为空，或者...
在学习中对于链表的实现。链表的增删查改等操作（C语言版）
GangStudyIT的博客
01-25 316
大家都不陌生，一个程序员，语言是基础，数据结构是核心之一，因此， 在学习过程中必须反复练习，那么今天我们来看看对与数据结构中，链表的实现。 首先，我们要明确，在线性表中有两类，一是顺序表，分为动态顺序表和静态顺序表， 我们前面有介绍静态，二是链表，链表又分为八种，即： 1.不带头不带环单向链表。（学习） 2.带头不带环单向链表。 3.不带头带环单向链表。 4.带头带环单向链表。 5
中国矿业大学(北京)在江西2020-2024各专业最低录取分数及位次表.pdf
最新发布
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
SOC与MCU启动区别的详细解析
10-02
本文深入剖析了SOC和MCU启动过程中显著的区别，包括硬件架构、启动速度、启动模式、电源管理和应用场景等方面的不同之处。文章指出了两种架构分别适用于复杂的系统集成以及简单的实时控制系统场合，为从事相关行业的工程人员提供了理论依据和技术指引。 适用人群：面向有初步认识嵌入式开发领域的学生和从业人员、尤其是致力于理解和区分SOC和MCU的技术特性与区别的人士。 使用场景及目标：针对不同应用场景——例如需要快速响应的智能家居设备和运行复杂操作系统的智能手机设备，选择最适合的芯片以优化产品性能。 其他说明：为了更好地掌握SOC和MCU之间的差异，建议读者们可以通过对比具体实例并结合实际工程项目进行综合评估学习。
校车调度管理系统 源码+数据库+论文（JAVA+SpringBoot+Vue.JS+MySQL）.zip
10-02
校车调度管理系统 源码+数据库+论文（JAVA+SpringBoot+Vue.JS+MySQL） 启动教程：https://www.bilibili.com/video/BV11ktveuE2d
数据结构讲解：循环链表与双向链表操作
"循环链表和双向链表的讲解，包括它们的定义、操作以及线性表的应用示例。" 在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值