C语言--带哨兵位的双向循环链表的创建及使用详解

最新推荐文章于 2024-05-19 09:38:30 发布
最新推荐文章于 2024-05-19 09:38:30 发布
阅读量1.2k 收藏 23
点赞数 26
文章标签： c语言 链表 开发语言 学习 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77637225/article/details/135658385
版权

C语言--带哨兵位的双向循环链表的创建及使用详解

1. 双向循环链表定义

1.1 定义

带哨兵位的双向循环链表是一种数据结构，它由多个节点组成，每个节点包含一个数据元素和两个指针，分别指向前一个节点和后一个节点，这样可以实现双向遍历。而且由于是循环链表，所以最后一个节点的后继节点是第一个节点，第一个节点的前驱节点是最后一个节点。与普通的双向循环链表不同的是，带哨兵位的链表在链表头部有一个哨兵节点，它不存储任何数据，仅用于简化链表操作。定义如下：

typedef int LTDataType;//定义存放数据的类型，便于不同类型数据的修改

typedef struct ListNode//定义链表结构
{
	struct ListNode* next;//指向下一个节点的地址
	struct ListNode* prev;//指向前一个数据的地址
	LTDataType data;//存放的数据
}LN;//重新命名

1.2 优点：

  1. 简化边界情况处理：哨兵节点的存在简化了对链表为空或者只有一个节点的情况的处理，使得代码更加简洁和易于理解。
  2. 方便实现循环遍历：由于是循环链表，可以方便地实现对链表的循环遍历，并且在实现迭代器等功能时也更加方便。
  3. 提高代码的可读性和可维护性：哨兵节点的引入使得链表操作的边界情况处理更加统一，减少了代码中的特殊情况处理，提高了代码的可读性和可维护性。

1.3 物理结构

物理结构如下图：
在这里插入图片描述

  1. 该链表的第一个节点为哨兵位节点，不存放任何数据。phead 的next指向的节点才是第一个数据存放的位子。尾节点的next指向头节点地址，头节点的prev指向尾节点地址
  2. 当链表仅剩下哨兵位时，perv 和 next 均指向自己，此时数据为空，链表中总会存在一个节点。在进行后面的操作的时候不需要判空，仅需要判别next 是否和prev 指向的位置相同

在这里插入图片描述

2. 双向链表的创建

2.1 文件创建

为方便代码管理，将文件内容分为三个文件来共同组成单链表，如下：

List.h//存放函数的声明、链表定义
List.c//存放具体函数的定义，用于函数的实现
test.c//测试文件，用于测试函数的功能

链表的定义：

typedef int LTDataType;//定义存放数据的类型，便于不同类型数据的修改

typedef struct ListNode//定义链表结构
{
	struct ListNode* next;//指向下一个节点的地址
	struct ListNode* prev;//指向前一个数据的地址
	LTDataType data;//存放的数据
}LN;//重新命名

2.2 节点创建

链表结构由一个个链表节点前后链接而成，每个链表节点的开辟如下：

//新链表要完成数据数据插入，然后传回插入过后的地址
LN* BuyList(LTDataType x)
{
	LN* newnode = (LN*)malloc(sizeof(LN));//开辟新的节点空间
	newnode->data = x;//放入数据
	//前后节点指向置空
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;//返回新开辟空间的地址
}

3. 链表操作

3.1 初始化

带哨兵位的双向链表的初始化需要创建一个哨兵位，同时将头指针和尾指针都指向哨兵位的地址，物理图如下：
在这里插入图片描述
代码如下：

//初始化的本质是创建一个不放数据的节点，返回该节点地址
LN* ListInit()
{
	LN* phead = BuyList(0);//创建的哨兵位节点
	phead->next = phead;//头节点指向哨兵位自己
	phead->prev = phead;//尾节点指向哨兵位自己
	return phead;//返回创建的哨兵位的地址
}

3.2 显示

形参 phead 来接收整个链表的头地址 phead 的值，通过 phead 来访问显示链表中的数据。代码如下：

//显示操作仅对链表内部内容进行操作，仅需要哨兵位节点就可以访问所有数据
void ListPrint(LN* phead)
{
	//phead指向的是哨兵位的位置，第一个数据在哨兵位之后
	LN* cur = phead->next;//寻找第一个数据的位置
	
	//循环结构，当尾指针指向哨兵位时完成一个循环
	//当链表里面仅剩哨兵位时，cur指向的仍为phead,循环直接结束
	while (cur != phead)
	{
		printf("%d-> ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

3.3 尾插

将最后一个节点tail 的next 指向新的节点newnode，新的节点newnode 的next 指向 phead，新的节点newnode 的prev 指向最后一个节点 tail 的地址，phead 的prev 指向新节点newnode 的地址.
在这里插入图片描述

//尾插需要链表的哨兵位节点与要插入的数据，不需要返回任何值
void ListPushBack(LN* phead, LTDataType x)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错

	LN* tail = phead->prev;//找尾节点
	LN* newnode = BuyList(x);//新建节点
	//将新节点链接到尾节点tail之后，再与哨兵位链接
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

3.4 头插

将第一个数据节点first 的prev 指向新的节点newnode，新的节点newnode 的prev 指向 phead，新的节点newnode 的next 指向第一个节点 first的地址 ，phead 的next 指向新节点newnode 的地址.
在这里插入图片描述

//头插需要链表的哨兵位节点与要插入的数据，不需要返回任何值
void ListPushFront(LN* phead, LTDataType x)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错

	LN* first = phead->next;//找到第一个数据的位置
	LN* newnode = BuyList(x);//新建节点
	//将新节点插入哨兵位之后，first之前
	first->prev = newnode;
	newnode->prev = phead;
	newnode->next = first;
	phead->next = newnode;
}

3.5 尾删

pead 的prev 指向倒数第二个数据pretail 的地址，prevtail 的next 指向phead 的地址,释放tail 的空间。
在这里插入图片描述

//尾删仅需要找到尾节点的位置，改变节点位置即可，不需要返回任何值
void ListPopBack(LN* phead)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错
	assert(phead->next != phead);//断言，当链表内容为空的时候报错

	LN* tail = phead->prev;//寻找尾节点
	LN* prevtail = tail->prev;//寻找尾节点之前的节点
	//改变链接顺序，将倒数第二个节点与哨兵位链接起来
	prevtail->next = phead;
	phead->prev = prevtail;
	//释放最后一个节点的空间
	free(tail);
	tail = NULL;
}

3.6 头删

pead 的next 指向第二个数据second 的地址，second 的prev 指向phead 的地址,释放first 的空间。
在这里插入图片描述

//头删仅需要找到第一个数据的的位置，改变节点位置即可，不需要返回任何值
void ListPopFront(LN* phead)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错
	assert(phead->next != phead);//断言，当链表内容为空的时候报错

	LN* first = phead->next;//寻找第一个数据存放节点
	LN* second = first->next;//寻找第二个数据存放节点
	//改变链接顺序，将第二个节点与哨兵位链接起来
	second->prev = phead;
	phead->next = second;
	//释放第一个节点的空间
	free(first);
	first = NULL;
}

3.7 查找

通过给定的数据，以遍历的方式寻找该数据，如果存在，则返回该数据的位置，不存在则返回空。

//查找需要被查找具体的数据，并且返回该数据的位置
LN* ListFind(LN* phead, LTDataType x)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错

	LN* cur = phead->next;//第一个数据的位置
	while (cur != phead)//最坏情况为找一圈也不见要查找的数据
	{
		if (cur->data == x)//找到数据则返回地址
		{
			return cur;
		}
		cur=cur->next;
	}
	return NULL;//为找到数据则返回空
}

3.8 指定位置前插入

将指定数据节点pos 的prev 指向新的节点newnode，新的节点newnode 的prev 指向 prevpos，新的节点newnode 的next 指向pos的地址 ，prevpos 的next 指向新节点newnode 的地址.
在这里插入图片描述

//指定位置前插入需要指定的位置以及需要插入的数据
void ListInsert(LN* pos, LTDataType x)
{
	assert(pos);//断言，在链表哨兵位节点被误删时报错

	LN* prev = pos->prev;//找到指定位置前一个数据的位置
	LN* newnode = BuyList(x);//定义新的节点
	//将新的节点插入指定节点前面
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = prev;
	prev->next = newnode;

}

3.9 指定位置删除

nextpos 的prev 指向prevpos 的地址，prevpos 的next 指向nextpos 的地址,释放pos 的空间。

在这里插入图片描述

//指定位置删除仅需指定的位置即可
void ListErase(LN* pos)
{
	assert(pos);//断言，在链表哨兵位节点被误删时报错

	LN* PosNext = pos->next;//找到指定位置后一个数据的位置
	LN* PosPrev = pos->prev;//找到指定位置前一个数据的位置
	//将指定位置前的数据与指定位置后的数据链接起来
	PosNext->prev = PosPrev;
	PosPrev->next = PosNext;
	//释放指定位置的空间
	free(pos);
	pos = NULL;
}

3.10 链表销毁

通过哨兵位，将所有的链表空间一个一个的释放，最后将哨兵位的空间释放。

//链表销毁需要对整个链表进行操作
void ListDstroy(LN* phead)
{
	assert(phead);//断言，在链表哨兵位节点被误删时报错

	LN* cur = phead->next;//找到第一个数据的位置
	while (cur != phead)
	{
		LN* next = cur->next;//找到下一个数据的位置
		free(cur);//释放当前数据的空间
		cur = next;//cur重新变为存在数据的对一个位置
	}
	//释放哨兵位节点空间
	free(phead);
	phead = NULL;
}

4. 链表总内容

4.1 List.c 文件

#define  _CRT_SECURE_NO_WARNINGS

#include "List.h"

LN* BuyList(LTDataType x)
{
	LN* newnode = (LN*)malloc(sizeof(LN));
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

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

LN* ListInit()
{
	LN* phead = BuyList(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void ListDstroy(LN* phead)
{
	assert(phead);

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

void ListPushBack(LN* phead, LTDataType x)
{
	assert(phead);

	/*LN* tail = phead->prev;
	LN* newnode = BuyList(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;*/

	ListInsert(phead->prev, x);

}

void ListPushFront(LN* phead, LTDataType x)
{
	assert(phead);

	/*LN* first = phead->next;
	LN* newnode = BuyList(x);

	first->prev = newnode;
	newnode->prev = phead;
	newnode->next = first;
	phead->next = newnode;*/

	ListInsert(phead->next, x);
}

void ListPopBack(LN* phead)
{
	assert(phead);
	/*assert(phead->next != phead);

	LN* tail = phead->prev;
	LN* prevtail = tail->prev;
	prevtail->next = phead;
	phead->prev = prevtail;

	free(tail);
	tail = NULL;*/
	ListErase(phead->prev);
}

void ListPopFront(LN* phead)
{
	assert(phead);
	/*assert(phead->next!=phead);


	LN* first = phead->next;
	LN* second = first->next;
	second->prev = phead;
	phead->next = second;

	free(first);
	first = NULL;*/

	ListErase(phead->next);

}

LN* ListFind(LN* phead, LTDataType x)
{
	assert(phead);

	LN* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur=cur->next;
	}
	return NULL;
}

void ListInsert(LN* pos, LTDataType x)
{
	assert(pos);

	LN* prev = pos->prev;
	LN* newnode = BuyList(x);
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = prev;
	prev->next = newnode;

}

void ListErase(LN* pos)
{
	assert(pos);

	LN* PosNext = pos->next;
	LN* PosPrev = pos->prev;
	PosNext->prev = PosPrev;
	PosPrev->next = PosNext;

	free(pos);
	pos = NULL;
}

4.2 List.h文件

#define  _CRT_SECURE_NO_WARNINGS

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

typedef int LTDataType;

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

LN* BuyList(LTDataType x);

LN* ListInit();

void ListDstroy(LN* phead);

void ListPushBack(LN* phead, LTDataType x);

void ListPrint(LN* phead);

void ListPushFront(LN* phead, LTDataType x);

void ListPopBack(LN* phead);

void ListPopFront(LN* phead);

LN* ListFind(LN* phead, LTDataType x);

void ListInsert(LN* pos,LTDataType x);

void ListErase(LN* pos);

4.3 test.c文件

#define  _CRT_SECURE_NO_WARNINGS

#include "List.h"

void test1()
{
	LN* plist = NULL;//链表头位置的创建
	plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

	ListPushFront(plist, 0);
	ListPushFront(plist, -1);
	ListPrint(plist);

	ListPopFront(plist);
	ListPrint(plist);

	ListPopBack(plist);
	ListPrint(plist);
}

void test2()
{
	LN* plist = NULL;
	plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPrint(plist);

	LN* pos = ListFind(plist, 3);
	if (pos)
	{
		ListInsert(pos, 0);
	}
	ListPrint(plist);

	ListErase(pos);
	ListPrint(plist);
}
int main()
{
	//test1();
	test2();

	return 0;
}

test1函数结果
在这里插入图片描述
test2函数结果
在这里插入图片描述

5. 总结

双向循环链表创建的难度从总体来说是小于单向链表的，只要熟悉了单向链表的创建，双向循环链表将会很快得到解决。
同时链表的学习是往后很多数据结构类型学习的基础，熟练掌握链表，对后续的学习又很大的帮助。

小小分享君
关注
  • 26
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
链表 链表_使用C语言实现非循环双向链表_带头结点+尾结点
编程思想 —— 哨兵的使用
weixin_30732487的博客
11-02 807
LDA：Leading Dimension of A View topic - leading dimension? Clarification of the leading dimension in CUBLAS when transposing 完整的说法是：leading dimension of two-dimensional array（...
c语言哨兵法比较数大小,哨兵查找法（明解c语言） + 函数式宏
weixin_35671421的博客
05-17 467
vue&period;js初级入门之最基础的双向绑定操作首先在页面引入vue.js以及其他需要用到的或者可能要用到的插件(这里我多引用了bootstrap和jquery) 引用的时候需要注意文件的路径,准备工作这样基本就完成了,下面正式开始入门. vue. ...属性的定义以及&commat;synthesize的使用1.属性通常是指某些由对象封装或储存的数据.它可以是标志(如名称...
队列（C语言实现）
cw412524的博客
11-27 637
数据结构链式队列（C语言实现），包含丰富接口，干货满满！
c语言必学技能--哨兵查找法
会挖坑的小石头的博客
03-11 809
c语言必学技能--哨兵查找法
c语言链表有没有哨兵的区别,链表中的哨兵（sentinel）
weixin_42498163的博客
05-21 393
哨兵节点广泛应用于树和链表中，如伪头、伪尾、标记等，它们是纯功能的，通常不保存任何数据，其主要目的是使链表标准化，如使链表永不为空、永不无头、简化插入和删除。问题：删除链表中等于给定值val的所有节点。1，如果节点在中间，只需将该节点进行删除即可。2，如果节点在头部，则问题将有点复杂，不能直接将头节点删掉，这样会造成链表的丢失。通过设置哨兵节点，用来临时保存头部节点，最后在计算完毕以后，返回该节点...
C语言中双向链表和双向循环链表详解
08-30
主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
双向循环链表-C语言实现.doc
09-21
来点硬核的，莲花宝典，武林霸主
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
C语言，顺序查找（含哨兵）
qq_52785030的博客
06-30 2774
下面展示一些 内联代码片。 // A code block var foo = 'bar'; #include "stdio.h" int Search(int *a,int n) { int x; int i=n; printf("请输入要查询的数：\n"); scanf("%d",&x); a[0]=x; while(a[i]!=x) { i--; } return i; } int main() { int n,i; int m; printf("请输入序列的元素
C语言实现带哨兵节点的双向链表
10-05 183
C语言实现带哨兵节点的双向链表
C语言实现双向循环带哨兵链表
m0_60447315的博客
03-22 1206
C语言实现双向循环带哨兵链表
C语言数据结构(3)——带哨兵结点的循环双向链表
qq_43041053的博客
10-30 586
1.基本数据类型 typedef int LTDatatype; typedef struct LTNode { LTDatatype data; struct LTNode* pre; struct LTNode* next; }LTNode; 2.
c语言链表有没有哨兵的区别,三种链表及其哨兵
weixin_39614834的博客
05-21 290
来源：http://blog.csdn.net/nomasp/article/details/46671673三种链表的介绍原谅我拙劣的绘图能力，花了半天终于还是决定从网上找来了这三张图，因为环形链表的弧形箭头难以完美的展现出来。以下3张图片来自Wikipedia。 大家看着图片应该也都知道这分别是哪种链表了。那么链表到底是什么呢？它和前面的栈和队列一般，都是基本的数据结构，其中的各个对象按...
c语言学习笔记 - 顺序查找和哨兵查找比较
weixin_30437337的博客
02-21 467
今天学习C时用到了顺序查找和哨兵查找，做了一个比较，主要是学习下哨兵查找法 例如在一个数组里查找一个元素，没找到返回-1，找到了则返回这个数组的下标也就是键值。 用循序查找法： void arr_search(int arr[],int len,int key){ 　　int i=0; 　　while(1){ 　　　　if(i==len){ /...
编程技巧1_哨兵值
Neuclil的博客
10-06 2793
在两个元素的遍历比较过程中，可能会出现一个数组提前遍历结束的情况，为了避免这样的情况，我们可以引入哨兵值，该值是一个比较关系中的最大值或者最小值，这个哨兵值会被我们放在数组的最后一个元素，含有哨兵值的数组会比原数组多一个元素。这样的好处在于，遍历比较过程永远也不会出现提前结束的现象。 下面用归并排序中的合并两个有序的子数组为例说明哨兵值的威力： //编写一个Merge函数 public s
C语言（指针）7
奋斗的小羊的博客
05-14 1087
指针超超超详解
1830. 【提高组NOIP2007】统计数字(count.pas/c/cpp)
wrnxrxsb的博客
05-14 525
某次科研调查时得到了n个自然数，每个数均不超过1500000000（1.5*10^9）。已知不相同的数不超过10000个，现在需要统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。输出文件count.out包含m行（m为n个自然数中不相同数的个数），按照自然数从小到大的顺序输出。每行输出两个整数，分别是自然数和该数出现的次数，其间用一个空格隔开。100%的数据满足：1<=n<=200000，每个数均不超过1 500 000 000（1.5*10^9）第1行是整数n，表示自然数的个数。
c/c++笔试题总结
最新发布
qq_71286244的博客
05-19 530
c/c++面试题总结
c语言创建双向循环链表
05-22
双向循环链表是一种特殊的链表，它的每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点，而最后一个节点的后继指针指向头结点，头结点的前驱指针指向最后一个节点。下面是一个简单的 C 语言程序示例，用于创建双向循环链表： ```c #include <stdio.h> #include <stdlib.h> struct node { int data; struct node *prev; struct node *next; }; struct node *head = NULL; struct node *tail = NULL; void create_list(int n); void display_list(); int main() { int n; printf("Enter the number of nodes: "); scanf("%d", &n); create_list(n); printf("Data in the list:\n"); display_list(); return 0; } void create_list(int n) { int i, data; struct node *newNode; if (n <= 0) { printf("List size must be greater than zero.\n"); return; } head = (struct node*)malloc(sizeof(struct node)); if (head == NULL) { printf("Unable to allocate memory."); return; } printf("Enter the data of node 1: "); scanf("%d", &data); head->data = data; head->prev = NULL; head->next = NULL; tail = head; for (i = 2; i <= n; i++) { newNode = (struct node*)malloc(sizeof(struct node)); if (newNode == NULL) { printf("Unable to allocate memory."); break; } printf("Enter the data of node %d: ", i); scanf("%d", &data); newNode->data = data; newNode->prev = tail; newNode->next = head; tail->next = newNode; tail = newNode; head->prev = tail; } printf("List created successfully.\n"); } void display_list() { struct node *current; if (head == NULL) { printf("List is empty.\n"); return; } current = head; printf("List is:\n"); do { printf("%d\n", current->data); current = current->next; } while (current != head); } ``` 在这个程序中，我们定义了一个结构体 `node`，它包含三个成员：`data`，`prev` 和 `next`，分别表示节点的数据、前驱指针和后继指针。我们还定义了两个指针 `head` 和 `tail`，分别指向链表的头结点和尾结点。 在 `create_list` 函数中，我们首先创建头结点，并让 `head` 和 `tail` 指向头结点。然后通过 `for` 循环创建其他节点，并将它们插入到链表的尾部。每个节点的前驱指针指向上一个节点，后继指针指向下一个节点，最后一个节点的后继指针指向头结点，头结点的前驱指针指向最后一个节点。 在 `display_list` 函数中，我们首先判断链表是否为空，然后通过 `do-while` 循环遍历链表，输出每个节点的数据。由于这是一个双向循环链表，循环条件为 `current != head`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值