双向循环链表的实现

已于 2023-05-28 19:15:53 修改
阅读量183 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-05-28 19:12:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75413778/article/details/130912052
版权

目录

一.图形展示

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

1.链表的初始化（建立带有哨兵卫头节点的链表）

2.链表新节点的创造 

3.尾插 

 4.头插

5.尾删

6.头删 

7.查找一个数（返回地址）

 8.在pos位置之前插入元素

9.删除pos位置元素

10.打印函数

 11.释放空间

总节

全部代码 

一.图形展示

 图中展示的是带有哨兵卫头节点的双向循环链表，虽然图看起来比较复杂，但是，在运用中非常方便，插入删除操作都比链表相对简单

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

1.链表的初始化（建立带有哨兵卫头节点的链表）

LTNode* ListInit()
{
	//用哨兵卫的头节点   也可以用二级指针
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));     //建立哨兵卫头节点
	phead->next = phead;      
	phead->prev = phead;

	return phead;
}

2.链表新节点的创造 

在后面插入一个新节点时，都要引用该函数，去建立一个新节点

//建立一个新节点
LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));    //malloc一个新节点
	newnode->data = x;
	newnode->next = NULL;            //先置为NULL,以便后面插入使用
	newnode->prev = NULL;            //先置为NULL，以便后面插入使用
	return newnode;
}

3.尾插 

//尾插 （下面有图解）
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);           //phead不为NULL

	LTNode* tail = phead->prev;          //找到原链表的尾节点
	LTNode* newnode = BuyListNode(x);   //调用建立结点的函数，建立新节点

	tail->next = newnode;          //尾节点的下一个结点为newnode
	newnode->prev = tail;          //newnode结点的前一个结点为tail
	newnode->next = phead;         //循环链表，所以newnode节点的next就是phead节点
	phead->prev = newnode;         //循环链表，所以phead的前一节点为newnode
}

 4.头插

头插和尾插的逻辑非常相似

//头插（下面有图解）  当只有头节点时，也可以用，不用考虑特殊情况
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);      //断言，phead不为NULL
	LTNode* newnode = BuyListNode(x);   //调用函数去建立新节点
	LTNode* next = phead->next;

	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

情况1：只有头节点的头插   phead = next  

情况2：正常的头插 （不仅仅只有头节点）

5.尾删

//尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  //防止把哨兵卫的头节点给删了

	LTNode* end = phead->prev;     //end是尾节点
	LTNode* tail = end->prev;      //tail是尾节点的前一个节点

	phead->prev = tail;
	tail->next = phead;

	free(end);             
    end = NULL;     //end置不置空， 都可以，end为形参，函数执行完之后，会自动设为NULL
}

6.头删 

//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);                      
	assert(phead->next != phead);       //防止把哨兵卫的头节点给删了

	LTNode* next = phead->next;
	LTNode* nextNext = next->next;

	phead->next = nextNext;
	nextNext->prev = phead;
	free(next);
}

7.查找一个数（返回地址）

//查找一个数
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;   //phead处是随机值，从phead下一个开始
	while (cur != phead)         //遍历链表，寻找要查找的数
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

 8.在pos位置之前插入元素

可以配合前面的函数（查找一个数的位置）使用  

//pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);                 //断言，pos不为NULL
	LTNode* posPrev = pos->prev;        //定义pos前的节点为posPrev
	LTNode* newnode = BuyListNode(x);   //调用函数，创造一个节点

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

9.删除pos位置元素

可以配合前面的函数（查找一个数的位置）使用  

前面的头删和尾删都可以直接调用这个函数

//删除pos位置
void ListEnsert(LTNode* pos)
{
	assert(pos);

	LTNode* posPrev = pos->prev;       //定义pos前的位置为posPrev
	LTNode* posNext = pos->next;       //定义pos后的位置为posnext

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;     //可有可无，pos是形参，这个函数结束后无影响
}

 

10.打印函数

void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)      //遍历去打印函数
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

 11.释放空间

注意：释放空间后在哪里置空

//传一级指针有野指针存在的隐患，所以释放完后在主函数中置空
void ListDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}

	free(phead);
	//phead = NULL;  //传一级指针这个置空不起作用，要在主函数中置空
}
int main()
{
	TestList1();
	LTNode* plist = ListInit();

	ListPushBack(plist, 1);
	ListPushBack(plist, 2);

	ListDestroy(plist);
	plist = NULL;        //在用完链表后在主函数中置空，原函数中传的是一级指针，在原函数中置空不起作用
	return 0;
}

总节

  • 带头双向循环链表比单链表更好操作，虽然看起来结构挺复杂的，但是插入和删除都很方便
  • 运用了带哨兵卫的头节点，传参的时候用一级指针就行（不用带哨兵卫的头节点，传参要用二级指针）

全部代码 

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

typedef int LTDataType;

typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

LTNode* ListInit()
{
	//用哨兵卫的头节点   也可以用二级指针
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));     //建立哨兵卫头节点
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

//建立一个新节点
LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));    //malloc一个新节点
	newnode->data = x;
	newnode->next = NULL;            //先置为NULL,以便后面插入使用
	newnode->prev = NULL;            //先置为NULL，以便后面插入使用
	return newnode;
}

//尾插 
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* tail = phead->prev;          //找到原链表的尾节点
	LTNode* newnode = BuyListNode(x);   //调用建立结点的函数，建立新节点

	tail->next = newnode;          //尾节点的下一个结点为newnode
	newnode->prev = tail;          //newnode结点的前一个结点为tail
	newnode->next = phead;         //循环链表，所以newnode节点的next就是phead节点
	phead->prev = newnode;         //循环链表，所以phead的前一节点为newnode
}

//打印函数
void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);  //防止把哨兵卫的头节点给删了

	LTNode* end = phead->prev;     //end是尾节点
	LTNode* tail = end->prev;      //tail是尾节点的前一个节点

	phead->prev = tail;
	tail->next = phead;

	free(end);

	//ListEnsert(phead->prev); //这里可以直接调用删除pos位置的函数
}

//头插
void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);      //断言，phead不为NULL
	LTNode* newnode = BuyListNode(x);   //调用函数去建立新节点
	LTNode* next = phead->next;

	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

//删除pos位置
void ListEnsert(LTNode* pos)
{
	assert(pos);

	LTNode* posPrev = pos->prev;       //定义pos前的位置为posPrev
	LTNode* posNext = pos->next;       //定义pos后的位置为posnext

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;     //可有可无，pos是形参，这个函数结束后无影响
}


//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);       //防止把哨兵卫的头节点给删了

	/*LTNode* next = phead->next;
	LTNode* nextNext = next->next;

	phead->next = nextNext;
	nextNext->prev = phead;
	free(next);*/

	ListEnsert(phead->next);        //直接调用删除pos位置元素的函数
}

//查找一个数
LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;   //phead处是随机值，从phead下一个开始
	while (cur != phead)         //遍历链表，寻找要查找的数
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//pos位置之前插入
void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);                 //断言，pos不为NULL
	LTNode* posPrev = pos->prev;        //定义pos前的节点为posPrev
	LTNode* newnode = BuyListNode(x);   //调用函数，创造一个节点

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

//传一级指针有野指针存在的隐患，所以释放完后在主函数中置空
void ListDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}

	free(phead);
	//phead = NULL;  //传一级指针这个置空不起作用
}

int main()
{
	LTNode* plist = ListInit();
	
	printf("尾插：");
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);

	printf("头插：");
	ListPushFront(plist, 10);
	ListPushFront(plist, 20);
	ListPushFront(plist, 30);
	ListPrint(plist);

	printf("尾删：");
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);

	printf("头删：");
	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

	printf("删除2：");
	LTNode* pos = ListFind(plist, 2);   //找到2的位置
	if (pos)
	{
		ListEnsert(pos);
	}
	ListPrint(plist);

	printf("在3的前面插入30：");

	pos = ListFind(plist, 3);         //找到3的位置
	if (pos)
	{
		ListInsert(pos, 30);
	}
	ListPrint(plist);

	ListDestroy(plist);
	plist = NULL;              //需要在主函数中置空

	return 0;
}

感谢大家的观看，希望你能从这篇文章中学到一些东西（如有错误，提醒我，我会及时修改）

谢谢大家！！！

努力学英语lsd
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向循环链表的操作与实现
m0_37546257的博客
10-17 129
双向循环链表=普通单向链表+双指针域+循环功能； double_loop_link.h #ifndef _DOUBLE_LOOP_LINK #define _DOUBLE_LOOP_LINK #include <stdio.h> #include <stdlib.h> #include <string.h> #define DLOOP_ERR (-1) #define DLOOP_SUCCESS 0 #define DATA_TYPE_IS_CHAR #if def
双向循环链表操作的实现
m0_53676388的博客
01-24 2042
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
Python双向循环链表实现方法分析
09-20
【Python双向循环链表实现方法分析】 Python中的双向循环链表是一种特殊的数据结构，它具有两个指针，分别指向当前节点的前一个节点（prev）和后一个节点（next），并且链表的最后一个节点的next指针指向第一个节点...
C++实现双向循环链表
12-20
本文介绍了一个C++实现双向循环链表的实例，主要通过定义模板类`DblList`和结构体`DblNode`来完成。`DblNode`结构体包含了节点的数据成员`data`以及指向前驱和后继节点的指针`lLink`和`rLink`。结构体还提供了两种...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
最新发布
09-20
在本项目中，我们利用C语言构建了一个航空信息查询系统，该系统的核心数据结构是双向循环链表。双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。...
java双向循环链表的实现代码
09-05
}/*** 获取双向循环链表的第一个节点* @return 链表头节点*/public BothwayLoopLinked getFirst(){if (linkedId == null) return null;BothwayLoopLinked first = this;while (first.prev != first) first = first....
双向循环链表基本操作的实现
hellolde的博客
07-14 147
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef int ElemType, Status; typedef struct LNode //双向循环链表节点 { ElemType data; //数据 struct LNode* next; //指向下一个节点指针 struct LNode* prev; //指向前一个节点指针 }LNode, *DuC
双向循环链表实现
hxy1625309592的博客
12-15 1264
1.1 基本介绍 双向循环链表就是在双线链表的基础上首尾相连（第一个节点的prev指向最后一个节点，最后一个节点的next指向第一个节点）。 1.2 添加操作 1、思路分析 头部插入 当整个链表都为空时，添加操作。 头结点和尾节点都指向自己。 当链表不为空时，添加操作 先把当前头节点的上一跳地址给新元素的上一跳 然后让新节点的后驱指针指向head结点，再让head的前驱指针指向新元素。 更新head结点，让head结点指向新结点，更新tail结点，让tail的下一跳重新指向head
【链表】双向循环链表的实现
阿润菜菜的博客
11-08 184
双向循环链表
双向循环链表的简单实现
sinat_39061823的博客
07-10 2484
双向循环链表： 双向循环链表和双向链表的不同之处，是双向循环链表的尾部节点的next不指向NULL，而是指向第一个节点，而第一个节点的pre是指向尾部节点的。 双向循环链表的结构：（以下示意图均摘自来源： http://blog.csdn.net/fisherwan/ar） 双向循环链表的初始化： 链表中只有一个节点，
双向循环链表及其实现
厚积薄发的博客
09-25 367
1.什么是双向循环链表？ 双向循环链表结构是两个指针，一个头指针（指向链表的头部），一个尾指针（指向链表的尾部），当前循环链表的长度size. 每个节点LinedNode由一个前向的指针，一个后向的指针，一个当前节点的值。 2.双向循环链表的具体实现方法有哪些？ int get(int index) 获得指定的元素 intaddAtHead(int val) 头结点新增元素 intaddAtTail（int val）尾节点新增元素...
双向循环链表的基本操作: java语言实现
cqulun123的博客
05-12 2964
1. 双向循环链表简单介绍      双向循环链表(Doubly Circular Linked List)是循环链表的一种。双向循环链表在双向链表的基础上，将表头结点的前驱指针指向尾结点，尾结点的后驱指针指向表头结点，首尾相连形成一个双向环。2 双向循环链表的基本操作2.1 创建结点类//创建一个双向链表结点类，并用get，set方法获取其数据。 public class DCLLNode { ...
【数据结构】双向链表的实现
adcxhw的博客
04-07 1240
又是一篇万字文章，建议收藏。
数据结构：线性表之-循环双向链表(万字详解)
2301_77649794的博客
09-11 2012
双向链表（Doubly Linked List）是一种常见的链表数据结构。它与普通链表的区别在于，每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点，因此可以从任意一个节点开始，双向遍历整个链表。双向链表的节点通常由三部分组成：数据部分（存储节点的值）、前驱指针（指向前一个节点的指针）和后继指针（指向后一个节点的指针）。相比于单向链表，双向链表可以更方便地进行正反向遍历和节点的插入、删除操作。
C++双向循环链表详解与模板实现教程
本课程设计详细介绍了如何在C++中实现双向循环链表，并利用模板技术进行编码。首先，我们从基本概念开始，双向循环链表（doubly circular list）是一种特殊的链表结构，它允许元素在链表中双向移动，包括头节点和尾...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值