循环双链表详解（C语言版）

最新推荐文章于 2024-04-20 21:28:50 发布
最新推荐文章于 2024-04-20 21:28:50 发布
阅读量1.4w 收藏 142
点赞数 27
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44075108/article/details/109224957
版权

文章目录

前言

        之前学习的双链表结构，可以实现从表中任一结点出发找到链表中的其他结点，但是该结构如果要从头结点开始查找尾结点，那么就需要通过遍历查找尾结点，这种情况下双链表的效率较低，为了解决这个缺点，将其改进为循环双链表，以此来提高查找效率。

在这里插入图片描述

一、循环双链表的定义

        循环双链表是对双链表的改进，将尾结点与头结点建立连接，使得尾结点可以直接查找到头结点，头结点也能够直接查找到头结点，以此来提高查找的效率。

二、循环双链表的结构

结构图
在这里插入图片描述
代码描述

#define ElemType int
//循环双链表结点结构
typedef struct Node
{
	ElemType data;     //数据域
	struct Node *prio; //前驱结点指针域
	struct Node *next; //后继结点指针域
}Node, *PNode;

//双链表结点管理结构
typedef struct List
{
	PNode first; //指向首结点（首结点不存放数据）
	PNode last;  //指向尾结点
	int   size;  //记录有效结点数
}List;

三、循环双链表的常用操作

初始化循环双联链表

//初始化双链表
void InitDCList(List *list)
{
	//申请头结点空间
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将头结点连接入管理结点
	list->first = list->last = s;
	//设置前驱指针指向（指向头结点）
	list->first->prio = list->last;
	//设置后继结点指向（指向尾结点）
	list->last->next  = list->first;
	list->size = 0;
}

获取结点

//获取结点
Node* _buynode(ElemType x)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	s->data = x;
	s->next = s->prio = NULL;
	return s;
}

尾插

void push_back(List *list, ElemType x)
{
	//获取结点
	Node *s = _buynode(x);
	//将插入结点与头结点连接
	s->next = list->last->next;
	s->next->prio = s;
	//将插入结点与上一尾结点连接
	s->prio = list->last;
	list->last->next = s;
	//修改双向链表管理结点的尾指针
	list->last = s;
	list->size++;
}

头插

//头插
void push_front(List *list, ElemType x)
{
	//获取插入结点
	Node *s = _buynode(x);
	//连接新插入结点和其下一个结点
	s->next = list->first->next;
	s->next->prio = s;
	//插入结点和头结点
	s->prio = list->first;
	list->first->next = s;
	//如果这个结点是第一个有效结点，需要更改管理结点尾指针的指向
	if(list->first == list->last)
		list->last = s;
	list->size++;
}

查看循环双链表数据

//查看循环双链表数据
void show_list(List *list)
{
	//指向第一个有效结点
	Node *p = list->first->next;
	//将所有有效结点输出
	while(p != list->first)
	{
		printf("%d-->",p->data);
		p = p->next;
	}
	printf("Nul.\n");
}

尾删

//尾删
void pop_back(List *list)
{   
	//如果没有有效结点，那么不进行删除
	if(list->size == 0)
		return;
	//设置管理结点的尾部指针指向
	Node *p = list->last;
	list->last = list->last->prio;
	//删除结点
	p->next->prio = p->prio;
	p->prio->next = p->next;
	free(p);
	list->size--;
}

头删

//头删
void pop_front(List *list)
{
	//如果没有有效结点不进行删除
	if(list->size == 0)
		return;
	//删除结点
	Node *p = list->first->next;
	p->next->prio = p->prio;
	p->prio->next = p->next;
	//如果只有一个有效结点，需要更改管理结点尾指针指向
	if(list->size == 1)
		list->last = list->first;
	list->size--;
}

按值插入(由小到大的顺序)

//按值插入(由小到大的顺序)
void insert_val(List *list, ElemType x)
{
	Node *p = list->first;//先指向头结点
	//查找要插入结点的位置
	while(p->next!=list->last && p->next->data < x)
		p = p->next;
	//如果插入的位置在最后，则进行尾插
	if(p->next==list->last && p->next->data<x)
	{
		push_back(list,x);
	}
	else //普通插入
	{
		Node *s = _buynode(x);
		s->next = p->next;
		s->next->prio = s;
		s->prio = p;
		p->next = s;
		list->size++;
	}
}

查找某一个值所在的位置

//查找某一个值所在的位置
Node* find(List *list, ElemType key)
{
	//从第一个有效结点位置开始查找
	Node *p = list->first->next;
	while(p != list->first && p->data != key)
		p = p->next;
	//如果没有找到返回空
	if(p == list->first)
		return NULL;
	return p;
}

获取有效结点个数

//获取有效结点个数
int  length(List *list)
{
	return list->size;
}

按值删除

//按值删除
void delete_val(List *list, ElemType key)
{
	//如果没有有效结点，则无需删除
	if(list->size == 0)
		return;
	//查找要删除结点所在的位置
	Node *p = find(list,key);
	//如果没有找到，无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存在.\n");
		return;
	}
	//如果这个结点是尾结点，则进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else//否则进行普通删除
	{
		p->next->prio = p->prio;
		p->prio->next = p->next;
		free(p);
		list->size--;
	}
}

排序(按照由小到大排序)

//排序(按照由小到大排序)
void sort(List *list)
{
	//如果有效结点数小于等于1，则无需排序
	if(list->size==0 || list->size==1)
		return;
	//将原来的循环双链表，分解成两条
	Node *s = list->first->next;
	Node *q = s->next;
	list->last->next = NULL;
	list->last = s;
	list->last->next = list->first;
	list->first->prio = list->last;

	//从第二条链表中不断拿取元素按值插入(由小到大)到第一条循环链表中
	while(q != NULL)
	{
		//拿取元素
		s = q;
		q = q->next;

		//按值插入（由小到大）
		Node *p = list->first;//查找插入位置
		while(p->next!=list->last && p->next->data < s->data)
			p = p->next;
		
		if(p->next==list->last && p->next->data<s->data)
		{//尾插
			s->next = list->last->next;
			s->next->prio = s;
			s->prio = list->last;
			list->last->next = s;
			list->last = s;
		}
		else
		{//普通插入
			s->next = p->next;
			s->next->prio = s;
			s->prio = p;
			p->next = s;
		}
	}
}

逆置

//逆置
void resver(List *list)
{
	//如果有效结点数小于等于1，则无需排序
	if(list->size==0 || list->size==1)
		return;
	//将原来的循环双链表，分解成两条
	Node *p = list->first->next;
	Node *q = p->next;
	list->last->next = NULL;
	list->last = p;
	list->last->next = list->first;
	list->first->prio = list->last;

	//从第二条链表中不断拿取元素头插到第一条循环链表中
	while(q != NULL)
	{
		//获取元素
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		p->next->prio = p;
		p->prio = list->first;
		list->first->next = p;
	}
}

清空有效结点

//清空有效结点
void clear(List *list)
{
	//如果没有结点
	if(list->size == 0)
		return;
	//从第一个有效结点开始
	Node *p = list->first->next;
	while(p != list->first)
	{
		//清空释放有效结点（头删）
		p->next->prio = list->first;
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	list->last = list->first;
	list->size = 0;
}

销毁循环双链表

//销毁循环双链表
void destroy(List *list)
{
	//清空释放所有有效结点
	clear(list);
	free(list->first);
	//清空管理结点
	list->first = list->last = NULL;
}

结语

        对循环双链表的介绍就到这里，希望这篇文章能够给予你一些帮助。

在这里插入图片描述

附录

以下提供循环双链表的测试代码

DCList.h

#ifndef __DCLIST_H__
#define __DCLIST_H__

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

#define ElemType int
//循环双链表结点结构
typedef struct Node
{
	ElemType data;     //数据域
	struct Node *prio; //前驱结点指针域
	struct Node *next; //后继结点指针域
}Node, *PNode;

//双链表结点管理结构
typedef struct List
{
	PNode first; //指向首结点（首结点不存放数据）
	PNode last;  //指向尾结点
	int   size;  //记录有效结点数
}List;

Node* _buynode(ElemType x);
void InitDCList(List *list);

void push_back(List *list, ElemType x);
void push_front(List *list, ElemType x);
void show_list(List *list);

void pop_back(List *list);
void pop_front(List *list);
void insert_val(List *list, ElemType x);
Node* find(List *list, ElemType key);
int  length(List *list);
void delete_val(List *list, ElemType key);
void sort(List *list);
void resver(List *list);
void clear(List *list);
void destroy(List *list);

#endif //__DCLIST_H__

DCList.cpp

#include"DCList.h"

//获取结点
Node* _buynode(ElemType x)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	s->data = x;
	s->next = s->prio = NULL;
	return s;
}

//初始化双链表
void InitDCList(List *list)
{
	//申请头结点空间
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将头结点连接入管理结点
	list->first = list->last = s;
	//设置前驱指针指向（指向头结点）
	list->first->prio = list->last;
	//设置后继结点指向（指向尾结点）
	list->last->next  = list->first;
	list->size = 0;
}
//尾插
void push_back(List *list, ElemType x)
{
	//获取结点
	Node *s = _buynode(x);
	//将插入结点与头结点连接
	s->next = list->last->next;
	s->next->prio = s;
	//将插入结点与上一尾结点连接
	s->prio = list->last;
	list->last->next = s;
	//修改双向链表管理结点的尾指针
	list->last = s;
	list->size++;
}

//头插
void push_front(List *list, ElemType x)
{
	//获取插入结点
	Node *s = _buynode(x);
	//连接新插入结点和其下一个结点
	s->next = list->first->next;
	s->next->prio = s;
	//插入结点和头结点
	s->prio = list->first;
	list->first->next = s;
	//如果这个结点是第一个有效结点，需要更改管理结点尾指针的指向
	if(list->first == list->last)
		list->last = s;
	list->size++;
}
//查看循环双链表数据
void show_list(List *list)
{
	//指向第一个有效结点
	Node *p = list->first->next;
	//将所有有效结点输出
	while(p != list->first)
	{
		printf("%d-->",p->data);
		p = p->next;
	}
	printf("Nul.\n");
}
//尾删
void pop_back(List *list)
{   
	//如果没有有效结点，那么不进行删除
	if(list->size == 0)
		return;
	//设置管理结点的尾部指针指向
	Node *p = list->last;
	list->last = list->last->prio;
	//删除结点
	p->next->prio = p->prio;
	p->prio->next = p->next;
	free(p);
	list->size--;
}
//头删
void pop_front(List *list)
{
	//如果没有有效结点不进行删除
	if(list->size == 0)
		return;
	//删除结点
	Node *p = list->first->next;
	p->next->prio = p->prio;
	p->prio->next = p->next;
	//如果只有一个有效结点，需要更改管理结点尾指针指向
	if(list->size == 1)
		list->last = list->first;
	list->size--;
}
//按值插入(由小到大的顺序)
void insert_val(List *list, ElemType x)
{
	Node *p = list->first;//先指向头结点
	//查找要插入结点的位置
	while(p->next!=list->last && p->next->data < x)
		p = p->next;
	//如果插入的位置在最后，则进行尾插
	if(p->next==list->last && p->next->data<x)
	{
		push_back(list,x);
	}
	else //普通插入
	{
		Node *s = _buynode(x);
		s->next = p->next;
		s->next->prio = s;
		s->prio = p;
		p->next = s;
		list->size++;
	}
}

//查找某一个值所在的位置
Node* find(List *list, ElemType key)
{
	//从第一个有效结点位置开始查找
	Node *p = list->first->next;
	while(p != list->first && p->data != key)
		p = p->next;
	//如果没有找到返回空
	if(p == list->first)
		return NULL;
	return p;
}
//获取有效结点个数
int  length(List *list)
{
	return list->size;
}
//按值删除
void delete_val(List *list, ElemType key)
{
	//如果没有有效结点，则无需删除
	if(list->size == 0)
		return;
	//查找要删除结点所在的位置
	Node *p = find(list,key);
	//如果没有找到，无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存在.\n");
		return;
	}
	//如果这个结点是尾结点，则进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else//否则进行普通删除
	{
		p->next->prio = p->prio;
		p->prio->next = p->next;
		free(p);
		list->size--;
	}
}

//排序(按照由小到大排序)
void sort(List *list)
{
	//如果有效结点数小于等于1，则无需排序
	if(list->size==0 || list->size==1)
		return;
	//将原来的循环双链表，分解成两条
	Node *s = list->first->next;
	Node *q = s->next;
	list->last->next = NULL;
	list->last = s;
	list->last->next = list->first;
	list->first->prio = list->last;

	//从第二条链表中不断拿取元素按值插入(由小到大)到第一条循环链表中
	while(q != NULL)
	{
		//拿取元素
		s = q;
		q = q->next;

		//按值插入（由小到大）
		Node *p = list->first;//查找插入位置
		while(p->next!=list->last && p->next->data < s->data)
			p = p->next;
		
		if(p->next==list->last && p->next->data<s->data)
		{//尾插
			s->next = list->last->next;
			s->next->prio = s;
			s->prio = list->last;
			list->last->next = s;
			list->last = s;
		}
		else
		{//普通插入
			s->next = p->next;
			s->next->prio = s;
			s->prio = p;
			p->next = s;
		}
	}
}
//逆置
void resver(List *list)
{
	//如果有效结点数小于等于1，则无需排序
	if(list->size==0 || list->size==1)
		return;
	//将原来的循环双链表，分解成两条
	Node *p = list->first->next;
	Node *q = p->next;
	list->last->next = NULL;
	list->last = p;
	list->last->next = list->first;
	list->first->prio = list->last;

	//从第二条链表中不断拿取元素头插到第一条循环链表中
	while(q != NULL)
	{
		//获取元素
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		p->next->prio = p;
		p->prio = list->first;
		list->first->next = p;
	}
}
//清空有效结点
void clear(List *list)
{
	//如果没有结点
	if(list->size == 0)
		return;
	//从第一个有效结点开始
	Node *p = list->first->next;
	while(p != list->first)
	{
		//清空释放有效结点（头删）
		p->next->prio = list->first;
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	list->last = list->first;
	list->size = 0;
}
//销毁循环双链表
void destroy(List *list)
{
	//清空释放所有有效结点
	clear(list);
	free(list->first);
	//清空管理结点
	list->first = list->last = NULL;
}

Main.cpp

#include"DCList.h"

void main()
{
	List mylist;
	InitDCList(&mylist);

	ElemType Item;
	Node *p = NULL;
	int select = 1;
	while(select)
	{
		printf("**************************************\n");
		printf("* [1] push_back      [2] push_front  *\n");
		printf("* [3] show_list      [4] pop_back    *\n");
		printf("* [5] pop_front      [6] insert_val  *\n");
		printf("* [7] find           [8] length      *\n");
		printf("* [9] delete_val     [10] sort       *\n");
		printf("* [11] resver        [12] clear      *\n");
		printf("* [13*] destroy      [0] quit_system *\n");
		printf("**************************************\n");
		printf("请选择:>");
		scanf("%d",&select);
		if(select == 0)
			break;
		switch(select)
		{
		case 1:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_back(&mylist,Item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_front(&mylist,Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据:>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
		case 7:
			printf("请输入要查找的数据:>");
			scanf("%d",&Item);
			p = find(&mylist,Item);
			if(p == NULL)
			{
				printf("要查找的数据在链表中不存在.\n");
			}
			break;
		case 8:
			printf("双向循环链表的长度为:> %d \n",length(&mylist));
			break;
		case 9:
			printf("请输入要删除的值:>");
			scanf("%d",&Item);
			delete_val(&mylist,Item);
			break;
		case 10:
			sort(&mylist);
			break;
		case 11:
			resver(&mylist);
			break;
		case 12:
			clear(&mylist);
			break;
		//case 13:
		//	destroy(&mylist);
		//	break;
		default:
			printf("输入的命令错误,请重新输入.\n");
			break;
		}
	}
	destroy(&mylist);
}
红心火柴
关注
  • 27
    点赞
  • 踩
  • 142
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
C语言双向链表的表示与实现实例详解
09-04
双向链表，又称为双链表，是数据结构中的一种线性表，它在链表的基础上增加了指向前后节点的指针，使得每个节点不仅可以向前遍历，还可以向后遍历。在C语言中，双向链表的实现涉及到节点结构的定义、链表的初始化、...
数据结构（五）——双链表与循环链表
流逝
08-03 1373
数据结构（五) —— 双链表和循环链表
实现循环双链表各种基本运算的算法
xiezhi123456的博客
01-12 2438
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode {     ElemType data;//数据域     struct DNode *prior;//指向前驱结点     struct DNode *n...
数据结构-双链表(图解)
最新发布
2302_78381559的博客
04-20 1484
双链表是一种常用且重要的线性数据结构，它在计算机科学和软件工程中扮演着不可或缺的角色。相较于单链表，双链表的每个节点包含两个指针，分别指向其前驱节点（previous node）和后继节点（next node），这一特性使得双链表在数据操作上具有更高的灵活性。
【C语言数据结构】双链表详解（带头双向循环链表）
dhgiuyawhiudwqha的博客
04-05 2138
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4344
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
数据结构初级:链表-双向带头循环链表(C语言)
m0_70088853的博客
05-13 560
链表-双向带头循环链表(C语言)
C语言之双向链表详解及实例代码
12-31
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
C语言单循环链表的表示与实现实例详解
01-20
对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表，可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法，循环...
头疼的算法与数据结构——双向循环链表
sum_TW的博客
03-12 6087
一：双向循环链表的简介 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双链表的结构定义如下： struct node{ int data;//数据域 struct node* next;//后继 struct n
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3396
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
循环双向链表
李洙赫的博客
05-20 249
双向链表的优势： 代码实现： 1、定义一个结点结构 2、初始化链表 3、尾插 4、头插 5、 尾删 6、头删 7、打印链表 完整代码： //双向链表的创建 //定义结点 typedef struct Dlist { int data; struct Dlist* prev;//指向前指针 struct Dlist* next;//指向后指针 }Dlist; //初始化 然后返回一个带有哨兵位的链表 Dlist* InitDlis...
C语言通用双向循环链表操作函数集
weixin_33884611的博客
06-20 442
  说明      相比Linux内核链表宿主结构可有多个链表结构的优点，本函数集侧重封装性和易用性，而灵活性和效率有所降低。     可基于该函数集方便地构造栈或队列集。     本函数集暂未考虑并发保护。   一  概念      链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接次序实现。链表由一系列存储结点组成，结点可在运行时动态生成。每个结...
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5163
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
循环单链表的结构和定义
Fenice
02-26 1138
#include "stdafx.h" #include using namespace std; #include enum Status{OK,ERROR}; typedef int ElemType; typedef struct Lnode { ElemType num; ///结点元素类型为int Lnode *next;
C语言双向循环链表基本操作
Starry_皮皮星
03-26 386
#include<iostream> #include<cstring> #include<stdlib.h> using namespace std; typedef struct DLnode { int data; struct DLnode *prior; struct DLnode *next; }DLnode,*Dlnode; void ...
C语言实现双向循环链表
BeiXi's Blog
01-31 2374
在之前的文章中，我写过一篇关于C语言实现双向链表博文，介绍了双向链表的实现过程以及双向链表的优势，接下来我首先给大家介绍一下循环链表和双向链表的区别，之后再给大家介绍双向循环链表的具体实现。 循环链表和双向链表的区别 1、最后一个结点指针指向不同 在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是像双向链表那样置为NULL。此种情况还用于在最后一个结点后插入一个新的结点。 2、判...
详细介绍一下循环双向链表
05-23
循环双向链表（Circular Doubly Linked List）是一种数据结构，它与普通的双向链表相似，但它的最后一个节点指向第一个节点，形成一个环形结构。循环双向链表可以用来实现队列、栈、哈希表、LRU Cache等数据结构。 循环双向链表中的每个节点都包含两个指针：一个指向前一个节点，一个指向后一个节点。因此，它能够在 O(1) 时间内完成插入、删除、查找等操作。与普通的双向链表不同，循环双向链表的头节点和尾节点相邻，可以通过头节点和尾节点来遍历整个链表。 下面是循环双向链表的基本操作： 1. 插入节点：在链表的任意位置插入一个新节点，包括链表头和链表尾。 2. 删除节点：删除链表中任意一个节点，包括链表头和链表尾。 3. 遍历链表：按顺序遍历链表，可以从头节点或尾节点开始。 4. 查找节点：根据某个条件查找链表中的节点。 需要注意的是，在删除节点时，必须将该节点的前一个节点的 next 指针指向该节点的后一个节点，同时将该节点的后一个节点的 prev 指针指向该节点的前一个节点，从而维护链表的正确性。 循环双向链表的优点是可以在 O(1) 时间内完成插入、删除、查找等操作，但它的缺点是相较于普通链表，它的实现比较复杂，需要考虑循环的情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值