双向循环链表

最新推荐文章于 2024-06-12 21:47:26 发布
最新推荐文章于 2024-06-12 21:47:26 发布
阅读量101 收藏 1
点赞数 2
分类专栏： 数据结构初阶 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sun_F_Z/article/details/130642887
版权

本文介绍一种带有哨兵位的双向循环链表。

目录

哨兵位的双向循环链表

结构

初始化

创建新节点BuyNode（）

尾插

头插

尾删

头删

查找

插入

删除

销毁

完整代码

感谢观看！谢谢！！

哨兵位的双向循环链表

结构

如图所示，此链表有两个节点，一个prev指向前一个节点，一个next指向下一个节点。

代码：

typedef int LNDataType;//方便改动数据类型
typedef struct DListNode
{
	LNDataType data;
	struct DListNode* prev;//前一个节点
	struct DListNode* next;//后一个节点
}DLTN;

 

初始化

此链表带有哨兵位的 头节点，初始化时，就是将哨兵位创建出来，应是这样的结构：

让它自己指向自己。

代码： 

//初始化
DLTN* InitList()
{
	DLTN* head = BuyNode(-1);//BuyNode（）是创建节点的函数
	head->next = head;
	head->prev = head;
	return head;
}

创建新节点BuyNode（）

代码：

DLTN* BuyNode(LNDataType x)
{
	DLTN* node = (DLTN*)malloc(sizeof(DLTN));
	if (node == NULL)
	{
		perror("BuyNode malloc:");
		return NULL;
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;

	return node;
}

尾插

在链表尾部插入新节点，首先要找到尾部位置，此链表的优势就体现出来了，头节点的prev就是指向链表的尾部的，所以我们这样做：

代码： 

void DLPushBack(DLTN* phead, LNDataType x)
{
	//找尾
	DLTN* tail = phead->prev;
	//创建新节点
	DLTN* newnode = BuyNode(x);

	//连接
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

头插

在链表头部插入新节点，注意：此头部不是哨兵位节点，而是指有效链表的第一个节点。

和尾插一样的思路，先找头部位置：哨兵位的next指向头部位置。然后创建新节点，插入。

代码：

void DLPushFront(DLTN* phead, LNDataType x)
{
	//找头
	DLTN* head = phead->next;
	//创建新节点
	DLTN* newnode = BuyNode(x);

	//连接
	newnode->next = head;
	head->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

尾删

删除尾部节点

代码：

void DLTPopBack(DLTN* phead)
{
	assert(phead);
	assert(!DLTEmpty(phead));

	DLTN* tail = phead->prev;//记录尾部节点
	DLTN* tailprev = tail->prev;//记录尾部的前一个节点
    //连接尾部的前一个节点，使其成为新的尾部
	tailprev->next = phead;
	phead->prev = tailprev;
    //释放旧尾部节点
	free(tail);
}

注意：有效链表全部删除后，就只剩哨兵位，此时不可再删除。DLTEmpty()是一个判空函数，当有效链表为空时，会返回true,否则返回false。

代码：

bool DLTEmpty(DLTN* phead)
{
	assert(phead);
	return phead == phead->next;
}

头删

删除头部节点

代码：

void DLTPopFront(DLTN* phead)
{
	assert(phead);
	assert(!DLTEmpty(phead));

	DLTN* head = phead->next;//找头
	DLTN* headnext = head->next;//找：头部位置的下一个节点
    //连接，形成新的头
	phead->next = headnext;
	headnext->prev = phead;
    //释放旧的头
    free(head);
}

头删尾删大同小异，可互相参考。

查找

代码：

DLTN* DLTFind(DLTN* phead, LNDataType x)
{
	assert(phead);
	DLTN* cur = phead->next;
    //根据提供的数据查找，遍历一遍
    //注意：此链表是循环的，遍历时从头开始，回到头结束，就视为一遍。
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
    //找不到返回空指针
	return NULL;
}

插入

这里的插入是在指定位置的前面插入新的节点。

代码：

//插入
void DLTInsert(DLTN* pos, LNDataType x)
{
	assert(pos);
	DLTN* posprev = pos->prev;//记录指定位置的前一个节点
	DLTN* newnode = BuyNode(x);
    //插入新节点
	posprev->next = newnode;
	newnode->prev = posprev;
	pos->prev = newnode;
	newnode->next = pos;
}

删除

这里的删除是删除指定位置的节点。

代码：

//删除
void DLTErase(DLTN* pos)
{
	assert(pos);
	DLTN* posprev = pos->prev;//记录当前位置的前一个节点
	DLTN* posnext = pos->next;//记录当前位置的下一个节点
    //连接前一个节点和下一个节点
	posnext->prev = posprev;
	posprev->next = posnext;
    //释放当前节点
	free(pos);
}

销毁

遍历一遍链表，进行销毁

代码：

//销毁
void LTDestory(DLTN* phead)
{
	assert(phead);
	DLTN* cur = phead->next;
	while (cur != phead)
	{
		DLTN* curnext = cur->next;
		free(cur);
		cur = curnext;
	}
	free(phead);
}

完整代码

分三个文件：

list.h

存放函数的声明，结构体的定义，头文件的引用等

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int LNDataType;
typedef struct DListNode
{
	LNDataType data;
	struct DListNode* prev;
	struct DListNode* next;
}DLTN;

//初始化
DLTN* InitList();
//打印
void DLTPrint(DLTN* phead);

void DLPushBack(DLTN* phead, LNDataType x);
void DLPushFront(DLTN* phead, LNDataType x);


void DLTPopFront(DLTN* phead);
void DLTPopBack(DLTN* phead);

//查找
DLTN* DLTFind(DLTN* phead, LNDataType x);
//插入
void DLTInsert(DLTN* pos, LNDataType x);
//删除
void DLTErase(DLTN* pos);
//销毁
void LTDestory(DLTN* phead);

list.c

具体实现链表的功能。

#include"list.h"
DLTN* BuyNode(LNDataType x)
{
	DLTN* node = (DLTN*)malloc(sizeof(DLTN));
	if (node == NULL)
	{
		perror("BuyNode malloc:");
		return NULL;
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;

	return node;
}

bool DLTEmpty(DLTN* phead)
{
	assert(phead);
	return phead == phead->next;
}

//初始化
DLTN* InitList()
{
	DLTN* head = BuyNode(-1);
	head->next = head;
	head->prev = head;
	return head;
}
//打印
void DLTPrint(DLTN* phead)
{
	assert(phead);
	DLTN* cur = phead->next;
	printf("哨兵位<==>");
	while (cur != phead)
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
void DLPushBack(DLTN* phead, LNDataType x)
{
	//找尾
	DLTN* tail = phead->prev;
	//创建新节点
	DLTN* newnode = BuyNode(x);

	//连接
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

	
	//DLTInsert(phead, x);
}

void DLPushFront(DLTN* phead, LNDataType x)
{
	//找头
	DLTN* head = phead->next;
	//创建新节点
	DLTN* newnode = BuyNode(x);

	//连接
	newnode->next = head;
	head->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;


	//DLTInsert(phead->next, x);
}

void DLTPopBack(DLTN* phead)
{
	assert(phead);
	assert(!DLTEmpty(phead));

	DLTN* tail = phead->prev;
	DLTN* tailprev = tail->prev;

	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);

	//DLTErase(phead->prev);
}

void DLTPopFront(DLTN* phead)
{
	assert(phead);
	assert(!DLTEmpty(phead));

	DLTN* head = phead->next;
	DLTN* headnext = head->next;

	free(head);

	phead->next = headnext;
	headnext->prev = phead;

	//DLTErase(phead->next);
}


//查找
DLTN* DLTFind(DLTN* phead, LNDataType x)
{
	assert(phead);
	DLTN* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//插入
void DLTInsert(DLTN* pos, LNDataType x)
{
	assert(pos);
	DLTN* posprev = pos->prev;
	DLTN* newnode = BuyNode(x);

	posprev->next = newnode;
	newnode->prev = posprev;
	pos->prev = newnode;
	newnode->next = pos;
}
//删除
void DLTErase(DLTN* pos)
{
	assert(pos);
	DLTN* posprev = pos->prev;
	DLTN* posnext = pos->next;
	posnext->prev = posprev;
	posprev->next = posnext;
	free(pos);
}
//销毁
void LTDestory(DLTN* phead)
{
	assert(phead);
	DLTN* cur = phead->next;
	while (cur != phead)
	{
		DLTN* curnext = cur->next;
		free(cur);
		cur = curnext;
	}
	free(phead);
}

test.c

用来测试链表，可自行编写。

感谢观看！谢谢！！

Sun_F_Z
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
双向循环链表实现
hxy1625309592的博客
12-15 1232
1.1 基本介绍 双向循环链表就是在双线链表的基础上首尾相连（第一个节点的prev指向最后一个节点，最后一个节点的next指向第一个节点）。 1.2 添加操作 1、思路分析 头部插入 当整个链表都为空时，添加操作。 头结点和尾节点都指向自己。 当链表不为空时，添加操作 先把当前头节点的上一跳地址给新元素的上一跳 然后让新节点的后驱指针指向head结点，再让head的前驱指针指向新元素。 更新head结点，让head结点指向新结点，更新tail结点，让tail的下一跳重新指向head
ZEMAX操作数
CGwuvH66AS的博客
10-28 1万+
ZEMAX操作数
C语言双向循环链表
qq_45911878的博客
08-07 4297
C语言单向链表正向、反向、排序插入和链表逆转。
双向循环链表操作的实现
m0_53676388的博客
01-24 1779
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
数据结构——双向循环链表
qq_67611811的博客
08-28 1984
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
热门推荐
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
双向循环链表C++
Worthwhile_DUT的博客
11-23 1380
双向循环链表是在循环链表（不定义头指针，而是定义尾指针）的基础上，增加一个指针域，注意头节点的前驱是指向最后一个元素，链表中存在两个环。
C++实现双向循环链表
12-20
本文实例为大家分享了C++实现双向循环链表的具体代码，供大家参考，具体内容如下 一、概念 1.在双链表中的每个结点应有两个链接指针：  lLink -> 指向前驱结点 （前驱指针或者左链指针） rLink->指向后继结点...
Python双向循环链表实现方法分析
09-20
主要介绍了Python双向循环链表,结合实例形式分析了Python双向链表的定义、遍历、添加、删除、搜索等相关操作技巧,需要的朋友可以参考下
C++:十大排序
2301_80418172的博客
06-12 990
十大排序CPP
ACM算法学习路线、清单
qq_45477639的博客
06-10 1921
算法与数据结构学习路线
C语言刷题（函数）
2303_82176667的博客
06-09 798
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
C数据结构：排序
2301_80655639的博客
06-12 1001
若按照错误方法来：例如：begin = 0，end = 3，那么mid = 1，begin1 = 0，end1 = 2，递归左右区间为[0，2]也就是begin = 0，end = 2，那么mid = 1，begin1 = 0，end1 = 2，这样又递归就会出现栈溢出的情况，所以必须要按照 上面代码的方式走。然后这个for循环做的就是遍历原数组，将原数组的值减去最小值，这个值映射到count数组中，让这个下标的值++，这样就会统计这个值出现的次数，而与原数组建立的关系就是减去一个min的关系。
【高阶数据结构】红黑树详解
最新发布
liuty0125的博客
06-12 1083
在前面我们学习了平衡二叉树，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现，除了AVL树，下面我们要学习的红黑树也是处理二叉树自身缺陷的一种方式RED,BLACK,_kv(kv),_col(RED){}
数据结构--第九章--查找
2302_80052051的博客
06-09 667
插入过程：（1）若二叉排序树T为空，则创建一个key域为k的节点，将它作为根节点；（2）否则将k和根节点的关键字比较，若两者相等，则说明树中已有此关键字k，无须插入，直接返回0；（3）若Kkey，则将k插入根节点的左子树中，否则将它插入右子树中。哈希表又称散列表，是除顺序表存储结构，链表存储结构和索引存储结构之外的又一种存储线性表的存储结构。对于n个元素，二分查找成功时最多的关键字比较次数为：log2（n+1）不成功时最多的关键字比较次数为log2（n+1）等概率条件下ASL成功=
JAVA学习笔记DAY3——菜鸟教程面向对象+数据结构部分
weixin_47227105的博客
06-10 702
菜鸟教程面向对象八节，以及下面高级教程前半部分
【数据结构】利用单链表再实现通讯录
2402_82689232的博客
06-12 450
在之前顺序表的实现中，我们利用了顺序表实现了通讯录，基于上篇文章学习了单链表，本篇文章将介绍如何利用单链表再实现通讯录。建议收藏，方便回顾。
双向循环链表数据修改
08-07
双向循环链表是一种特殊的链表，其中每个节点都有一个指向前一个节点和后一个节点的指针。要修改双向循环链表中的数据，可以按照以下步骤进行操作： 1. 遍历链表，找到要修改数据的节点。 2. 更新节点的数据。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值