【数据结构】线性表——带头双向循环链表

已于 2023-05-10 17:28:24 修改
阅读量1.4k 收藏 30
点赞数 35
分类专栏： 数据结构理解与实现 文章标签： 链表 数据结构 c语言
于 2023-05-10 17:26:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65596720/article/details/130605636
版权

文章目录

带头双向循环链表

  • 带头双向循环链表的优点

1.支持任意位置时间复杂度为O(1)的插入和删除。

2.按照需求申请释放空间，无需担心空间不够用，无需担心浪费。

3.带头可以省去链表为空时的判断，可以使代码更加简约

  • 带头双向循环链表的缺点

1.不可以进行下标随机访问。

2.缓存利用率低

带头双向循环链表是线性表的一种，带头双向循环链表是链式存储的线性表，不同于顺序表，链表在内存空间中不连续。

  • 带头：带头就是带哨兵位，可以省链表为空时进行的判断。

  • 双向：由结构体内的next指针下一条数据进行链接，由prev对前一条数据进行链接🧐。

  • 循环：以循环方式进行链接，头的（前一个）prev是尾，尾的next（后一个）是头。

PS:需要源码直接通过目录跳转到最后

带头双向循环链表主体结构

默认大小与扩容大小还有类型都可以是任意大小或类型

typedef int DListDataType;		//数据类型

typedef struct ListNode
{
	DListDataType data;	
	struct ListNode* prev;		//指针指向前一个结点
	struct ListNode* next;		//指针指向后一个结点
}LTNode;

在这里插入图片描述

带头双向循环链表操作函数介绍

  1. LTNode* InitLTNode(); //链表初始化
  2. void ListInsert(LTNode* pos, DListDataType x); //任意位置插入
  3. void ListPushBack(LTNode* phead, DListDataType x); //尾插
  4. void ListPushFront(LTNode* phead, DListDataType x); //头插
  5. void print(LTNode* phead); //输出链表
  6. void ListErase(LTNode* pos); //任意位置删除
  7. void ListPopBack(LTNode* phead); //尾删
  8. void ListPopFront(LTNode* phead); //头删
  9. LTNode* LTModify(LTNode* phead, DListDataType x); //修改指定结点
  10. LTNode* LTFind(LTNode* phead, DListDataType x); //查找指定结点
  11. void LTDestory(LTNode* phead); //销毁链表

为了代码方便阅读，将带头双向循环链表操作函数全部放在LinkedList.c文件中，将头文件放在LinkedList.h，测试文件test.c 😮

带头双向循环链表操作函数实现

为了方便调试，建议每写完1-2个函数就进行测试，初始化之后，首先实现print函数可以方便我们进行调试。

带头双向循环链表的初始化函数：

LTNode* Phead = InitLTNode();	//初始化哨兵位

LTNode* BuyNewNode(DListDataType x)		//开辟一个新结点
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

LTNode* InitLTNode()
{
	LTNode* phead = BuyNewNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

必须先进行初始化哨兵位，将哨兵位指向自己形成循环

打印函数

先写出打印函数，方便进行调试

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

带头双向循环链表插入函数：

指定结点后插入和查找函数

两个函数可以配合使用，使用LTFind查找到需要插入的位置，然后使用ListInsert进行更改

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* BuyNewNode(DListDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

void ListInsert(LTNode* pos,DListDataType x)
{
	assert(pos);
	LTNode* newnode = BuyNewNode(x);
	LTNode* prev = pos->prev;

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

在这里插入图片描述

头插

头插将新结点插入到哨兵位后面的结点

这里面有一种简单的写法，就是直接复用ListInsert，将哨兵位后面的结点传过去，也是头插的效果

void ListPushFront(LTNode* phead, DListDataType x)
{
	assert(phead);
    //第一种方法
	//ListInsert(phead->next,x);
    //第二种方法
	LTNode* newnode = BuyNewNode(x);
	LTNode* secound = phead->next;
	newnode->next = secound;
	secound->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

尾插

从最后一个结点后面插入新结点

尾插也可以复用ListInsert函数

  • 尾插也会用到申请新结点的函数，这里不重复了
void ListPushBack(LTNode* phead, DListDataType x)
{
	assert(phead);
    //第一种办法
	//ListInsert(phead,x);
    //第二种办法
	LTNode* newnode = BuyNewNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

带头双向循环链表删除函数

指定结点删除

删除指定结点，配合STFInd使用，将指定节点前一个结点的next连接到指定结点后一个结点，再将指定结点后面结点的prev连接到指定指定结点前一个结点。

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
    free(pos);
}

头删

记得进行断言，当只有一个哨兵位时与头结点为空都无法进行删除

可以对STErase进行复用

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
    //第一种方法
	//ListErase(phead->next);
    //第二种
	LTNode* secound = phead->next;
	phead->next = secound->next;
	secound->next->prev = phead;
	free(secound);
}

尾删

void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
    //第一种方法
    //ListErase(phead->prev);
    //第二种方法
	LTNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
}

带头双向循环链表修改函数

配合LTFind函数使用

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* LTModify(LTNode* phead, DListDataType x)
{
	LTNode* pos = LTFind(phead, x);
	int y;
	scanf("%d", &y);
	pos->data = y;
}

销毁带头双向循环链表

将每个结点依次释放。最后将哨兵位释放。

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

源代码文件

🌞🌞为了使代码更有阅读性，我们不建议把所有函数写在一个文件里，所以这里分成三个文件，模块化管理

test.c

测试文件

#include "DList.h"

void test1()
{
	LTNode* Phead = InitLTNode();
	ListPushBack(Phead, 666);
	ListPushBack(Phead, 777);
	ListPushBack(Phead, 9999);
	ListPushBack(Phead, 888);
	print(Phead);
	ListPopBack(Phead);
	print(Phead);
	ListPopFront(Phead);
	print(Phead);
	ListPopFront(Phead);
	ListPopFront(Phead);
	print(Phead);
	ListPushFront(Phead,111);
	print(Phead);
	ListPushFront(Phead, 112);
	print(Phead);
	LTDestory(Phead);
	Phead = NULL;

}

int main()
{
	test1();
}

DList.c

i将所有函数封装在此文件下

#include "DList.h"


LTNode* BuyNewNode(DListDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return NULL;
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}
LTNode* InitLTNode()
{
	LTNode* phead = BuyNewNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void ListInsert(LTNode* pos,DListDataType x)
{
	assert(pos);
	LTNode* newnode = BuyNewNode(x);
	LTNode* prev = pos->prev;

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

void ListPushBack(LTNode* phead, DListDataType x)
{
	//ListInsert(phead,x);
	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

void ListPushFront(LTNode* phead, DListDataType x)
{
	//ListInsert(phead->next,x);
	assert(phead);
	LTNode* newnode = BuyNewNode(x);
	LTNode* secound = phead->next;
	newnode->next = secound;
	secound->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;
}

void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

void ListPopBack(LTNode* phead)
{
	//ListErase(phead->prev);
	assert(phead);
	assert(phead != phead->next);
	LTNode* tail = phead->prev;
	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead != phead->next);
	//ListErase(phead->next);
	LTNode* secound = phead->next;
	phead->next = secound->next;
	secound->next->prev = phead;
	free(secound);
}

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

LTNode* LTFind(LTNode* phead, DListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

LTNode* LTModify(LTNode* phead, DListDataType x)
{
	LTNode* pos = LTFind(phead, x);
	int y;
	scanf("%d", &y);
	pos->data = y;
}

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

DLlist.h

将主程序所需要的函数全部在头文件中声明，增加代码阅读性

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
#include <assert.h>

typedef int DListDataType;

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

LTNode* InitLTNode();
void ListInsert(LTNode* pos, DListDataType x);
void ListPushBack(LTNode* phead, DListDataType x);
void ListPushFront(LTNode* phead, DListDataType x);
void print(LTNode* phead);
void ListErase(LTNode* pos);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
LTNode* LTModify(LTNode* phead, DListDataType x);
LTNode* LTFind(LTNode* phead, DListDataType x);
void LTDestory(LTNode* phead);

撒花

这就是实现带头双向循环链表的全部内容了，创作不易，还请各位小伙伴多多点赞👍关注收藏⭐，以后也会更新各种关于c语言，数据结构的博客，撒花！

悲伤的猪大肠9
关注
专栏目录
线性表之带头双向循环链表
m0_62171658的博客
03-06 1438
初学者必备：线性表之带头双向循环链表接口实现和一些链表必备思想
数据结构线性表——顺序表、链表
qq_64105689的博客
05-14 696
1.线性表 线性表(linear list)是有n个相同特性的元素组成的有限序列，在逻辑上是线性结构，也就是连续的一条直线；但是在物理结构上，不一定是连续的。 常见的线性表有： 顺序表、链表、栈、队列、字符串.... 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的数据结构，一般采用数组存储，在数组上完成增删查改。 顺序表一般分为： 1.静态的顺序表：使用定长数组存储元素。 define N 6 typedef int SeqListDataType; t.
设以带头结点的双向循环链表表示的线性表L= (a1,a2,…,an),试写一时间复杂度O(n)的算法，将L改造为 (a1,a3,…,an,…,a4,a2)。
热门推荐
TysonSir的博客
03-27 1万+
/* 将L中的元素，按如下规则插入新表，并返回新表。 （1,2）->(1,3,2)->(1,3,4,2)->(1,3,5,4,2)->(1,3,5,6,4,2)->... */ DuLinkList Transform(DuLinkList L);
题目：设以带头结点的双向循环链表表示的线性表L=（a1,a2,…..,an）.试写出一时间复杂度为o(n)的算法，将L改造为L=（a1,a3,…,an,a4,a2）.
w_h007的博客
03-30 2182
题目：设以带头结点的双向循环链表表示的线性表L=（a1,a2,…..,an）.试写出一时间复杂度为o(n)的算法，将L改造为L=（a1,a3,…,an,a4,a2）
【C++数据结构学习笔记---线性表】带头结点的双向循环链表
EnCaL
03-14 1340
【C++数据结构学习笔记---线性表】带头结点的双向循环链表 一个简单的实现例子，只用到了插入函数以及输出函数，初始化26个英文字母。 插入算法的思路：（insert）本算法为结点后插入 1、声明一结点p指向头结点，初始化i从0开始。 2、遍历链表，让指针p向后移动，直至移动到要插入元素的结点，即向后移动k次。 4、让指针q指向p的右边一个结点。 5、在系统中新建一个结点s。 接
线性表和带头结点的双向循环链表
WhiskyCocktail的博客
11-29 517
带头节点的双链表的操作： #define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include #include #include using namespace std; //2. 以C++的方式实现双向循环链表 typedef int DataType; struct Node { struct Node* _pNext; struct N
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
线性表——循环链表、双向链表
m0_53359491的博客
12-07 664
目录一、循环链表1、定义和特点 2、初始化循环链表 3、求循环链表的长度4、遍历循环链表找到值为x的结点个数（重点在于遍历操作）5、循环链表的典型应用——约瑟夫环 二、双向链表1、定义和特点 2、双向链表的类型声明3、求双向循环链表的长度 4、双向循环链表插入算法5、双向循环链表删除结点算法 注：以下算法中循环链表的节点声明同单链表 3、求循环链表的长度 4、遍历循环链表找到值为x的结点个数（重点在于遍历操作） 5、循环链表的典型应用——约瑟夫环 题解代码： 运行结果
线性表——链表
weixin_59055853的博客
08-11 893
线性表第二关之链表来了，快来继续闯关！！！
数据结构题集（严蔚敏）2.37 改造带头结点的双循环链表
小82的科技小博客
11-06 3705
设以带头结点的双向循环链表表示的线性表L=a1,a2,a3...an。试写一时间复杂度O(n)的算法，将L改造为L=a1,a3,...an,...a4,a2。 void Reform(DuLinkedList &L)//按1,3,5,...4,2 的顺序重排双向循环链表 L中的所有结点 { p=L.next; while(p->next!=L&&p->next->next!=L
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂吨为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
11-29
设双链表表示的线性表L=（a1,a2,……an）,试写一时间复杂度为O(n)的算法，将L改造为L=（a1,a3……an……,a4,a2）
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
10-13
设双链表表示的线性表L=（a1,a2,....,an），试写一时间复杂度为O（n）的算法，将L改造为L=（a1,a2,,,,an....,a4,a2）。
数据结构：带头结点的双向循环链表
smx_dd的博客
04-05 566
头文件及函数声明：#include<stdio.h> #include<windows.h> #include<assert.h>typedef int DataType;typedef struct DListNode { struct DListNode* _next; struct DListNode* _prev; DataType _data; }DListNode
数据结构例题7
zzzbiu的博客
11-20 1083
1、设以带头结点的双向循环链表表示的线性表L=(a1，a2，…,an)，试写一算法，将L改造为L=(a1，a3，…，an…，a4，a2)。 void Exchange_DLinkList(DLinkList &L){ DLinkList p,q,tail; int count=0; //count记录数组下标；当数组下标为偶数时，当前结点移动到an后 p=L->next; tail=L->prior; //tail指向表尾结点an wh
找出n个数中相差最小两个数，并输出其差值的绝对值
宇宙观光巴士站
12-05 6546
求n个数中最小差值绝对值 -数据结构题目 题目：给定n个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。 算法思想：用比较的方法，通过差值的计算，逐个数据地找出与当前元素数据差值最小的元素，再将差值的绝对值返回。 c++代码如下： #include <iostream> #include <stdlib.h> using namespace std; typedef struct LNode { struct LNode *prior; //指针
带头结点的双向循环链表
dream8834的博客
08-30 927
DList.h //头文件 #ifndef __DLIST_H__ #define __DLIST_H__ typedef int DataType; typedef struct DListNode { struct DListNode* _pNext; struct DListNode* _pPre; DataType _data; }DListNode; ...
数据结构-线性表之带头结点的双向循环链表
快乐江湖的博客
01-26 1132
文章目录前言实现（1）结构定义（2）基本函数（3）操作实现测试代码 前言 链表的类型有很多种（根据带头或不带头，循环或非循环等等），但是我们重点研究的只有两种，一种结构非常简单是无头单向非循环链表，有关它的操作见 数据结构-线性表之单链表 这种结果在开发中基本不会使用，因为因为结构简单往往意味着操作复杂，比如在求职中OJ题，有关链表的基本都用的是这种结构，关于这些OJ题感兴趣的见 链表经典题 另一种则是链表中结构最为复杂的——带头结点的双向循环链表 这种结构看起来确实是很复杂的，但是它的操作很简单
【数据结构——线性表之链表】
lflcodeplus的博客
10-04 2299
线性表之《链表的表示及基本操作的实现》 目录线性表之《链表的表示及基本操作的实现》一、单链表（一）单链表的描述（一）单链表的操作实现1、初始化2、查找3、插入4、删除二、循环链表三、循环链表 一、单链表 （一）单链表的描述 typedef struct LNode { ElemType data;//结点数据域 struct LNode* next;//结点指针域 }LNode ,*LinkList; 变量定义： LNode* p, * q LinkList L; p, q, L都是指针变量，
【进阶】java基础之集合(2)数据结构＜树＞
最新发布
Y0UZI的博客
11-05 382
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值