带头双向循环链表增删查分析及代码实现（C语言实现）

最新推荐文章于 2023-08-10 21:56:53 发布

清晨白米稀饭.

最新推荐文章于 2023-08-10 21:56:53 发布

阅读量406

点赞数 2

分类专栏：数据结构与算法笔记文章标签：链表 c语言数据结构

本文链接：https://blog.csdn.net/weixin_64181464/article/details/122431372

版权

数据结构与算法笔记专栏收录该内容

11 篇文章 1 订阅

订阅专栏

带头双向循环链表分析及代码实现（C语言）

一、带头双向循环链表结构
二、代码
三、完整代码块

一、带头双向循环链表结构

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向
循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而
简单了，后面我们代码实现了就知道了。
在这里插入图片描述

二、代码

2.1、创建一个带头双向循环链表

首先定义一个结构体

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

然后创建出一个带头双向循环链表，要求头指向链表的尾，尾指向链表的头。

ListNode* ListCreate()//创建一个带头双向循环链表
{
	ListNode* plist = (ListNode*)malloc(sizeof(ListNode));//开辟一个空间
	plist->data = NULL;
	plist->next = plist;//尾指向头
	plist->prev = plist;//头指向尾
	return plist;//返回表头
}

2.2、开辟一个新的空间及打印链表

因为每次增加链表都需要开辟一个新的空间，所以为了方便把开辟新的空间封装成一个函数，到时候只需要调用这一个函数就可以。

ListNode* newcapaicty(LTDataType x)//开辟一个空间
{
	ListNode* newcapaicty = (ListNode*)malloc(sizeof(ListNode));
	newcapaicty->data = x;
	newcapaicty->next = NULL;
	newcapaicty->prev = NULL;
}

打印链表函数如下：

void ListPrint(ListNode* plist)//打印链表
{
	ListNode* tail = plist->next;
	while (tail != plist)
	{
		printf("%d", tail->data);
		tail = tail->next;
	}
	printf("\n");
}

2.3、链表尾插

void ListPushBack(ListNode* plist, LTDataType x)//尾插
{
	assert(plist);//判断pilst是否为NULL
	ListNode* newnode = newcapaicty(x);
	ListNode* tail = plist->prev;//每次进来都需找尾；无需遍历寻找
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = plist;
	plist->prev = newnode;
}

2.4、链表尾删

void ListPopBack(ListNode* plist)//尾删
{
	assert(plist->next!=plist);//判断传进来的链表是否有数据，当头的next指向自己就会警告
	ListNode* tail = plist->prev;
	ListNode* cur = tail->prev;
	plist->prev = cur;
	cur->next = plist;
	free(tail);
	tail = NULL;
}

2.5、链表头插

void ListPushFront(ListNode* plist, LTDataType x)//头插
{
	assert(plist);
	ListNode* newnode = newcapaicty(x);
	ListNode* head = plist->next ;//找头的后一项
	newnode->next = head;
	head->prev = newnode;
	plist->next = newnode;
	newnode->prev = plist;
}

2.6、链表头删

void ListPopFront(ListNode* plist)//头删
{
	assert(plist->next != plist);
	ListNode* head = plist->next;
	ListNode* tail = head->next;
	plist->next = tail;
	tail->prev = plist;
	free(head);
	head = NULL;
}

2.7链表的查找

ListNode* ListFind(ListNode* plist, LTDataType x)//查找
{
	ListNode* cur = plist->next;
	while (cur!= plist)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;		
	}
	return NULL;
}

2.8、在链表pos位置插入X

void ListInsert(ListNode* pos, LTDataType x)//在pos位置插入
{
	assert(pos);
	ListNode* newnode = newcapaicty(x);
	ListNode* head = pos->prev;
	newnode->prev = head;
	newnode->next = pos;
	head->next = newnode;
	pos->prev = newnode;
}

2.9、删除pos位置上的数据

void ListErase(ListNode* pos)//在pos位置删除
{
	assert(pos);
	ListNode* head = pos->prev;
	ListNode* tail = pos->next;
	head->next = tail;
	tail->prev = head;
	free(pos);
	pos = NULL;
}

2.10、链表的销毁

void ListDestory(ListNode* plist)//链表的销毁
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(plist);
}

三、完整代码块

SList.h的代码块

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;
ListNode* ListCreate();//创建一个带头循环双链表
ListNode* newcapaicty(LTDataType x);//开辟一个新的空间
void ListPrint(ListNode* plist);//打印链表
void ListPushBack(ListNode* plist, LTDataType x);//双链表的尾插
void ListPopBack(ListNode* plist);//双链表尾删
void ListPushFront(ListNode* plist, LTDataType x);//头插
void ListPopFront(ListNode* plist);//头删
ListNode* ListFind(ListNode* plist, LTDataType x);//查找
void ListInsert(ListNode* pos, LTDataType x);//在pos位置插入
void ListErase(ListNode* pos);//在pos位置删除

SList.c的代码块

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
ListNode* ListCreate()//创建一个带头双向循环链表
{
	ListNode* plist = (ListNode*)malloc(sizeof(ListNode));//开辟一个空间
	plist->data = NULL;
	plist->next = plist;//尾指向头
	plist->prev = plist;//头指向尾
	return plist;//返回表头
}
ListNode* newcapaicty(LTDataType x)//开辟一个空间
{
	ListNode* newcapaicty = (ListNode*)malloc(sizeof(ListNode));
	newcapaicty->data = x;
	newcapaicty->next = NULL;
	newcapaicty->prev = NULL;
}
void ListPrint(ListNode* plist)//打印链表
{
	ListNode* tail = plist->next;
	while (tail != plist)
	{
		printf("%d", tail->data);
		tail = tail->next;
	}
	printf("\n");
}
void ListPushBack(ListNode* plist, LTDataType x)//尾插
{
	assert(plist);//断言
	ListNode* newnode = newcapaicty(x);
	ListNode* tail = plist->prev;//每次进来都需找尾；无需遍历寻找
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = plist;
	plist->prev = newnode;
}
void ListPopBack(ListNode* plist)//尾删
{
	assert(plist->next!=plist);
	ListNode* tail = plist->prev;
	ListNode* cur = tail->prev;
	plist->prev = cur;
	cur->next = plist;
	free(tail);
	tail = NULL;
}
void ListPushFront(ListNode* plist, LTDataType x)//头插
{
	assert(plist);
	ListNode* newnode = newcapaicty(x);
	ListNode* head = plist->next ;
	newnode->next = head;
	head->prev = newnode;
	plist->next = newnode;
	newnode->prev = plist;
}
void ListPopFront(ListNode* plist)//头删
{
	assert(plist->next != plist);
	ListNode* head = plist->next;
	ListNode* tail = head->next;
	plist->next = tail;
	tail->prev = plist;
	free(head);
	head = NULL;
}
ListNode* ListFind(ListNode* plist, LTDataType x)//查找
{
	ListNode* cur = plist->next;
	while (cur!= plist)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;		
	}
	return NULL;
}
void ListInsert(ListNode* pos, LTDataType x)//在pos位置插入
{
	assert(pos);
	ListNode* newnode = newcapaicty(x);
	ListNode* head = pos->prev;
	newnode->prev = head;
	newnode->next = pos;
	head->next = newnode;
	pos->prev = newnode;
}
void ListErase(ListNode* pos)//在pos位置删除
{
	assert(pos);
	ListNode* head = pos->prev;
	ListNode* tail = pos->next;
	head->next = tail;
	tail->prev = head;
	free(pos);
	pos = NULL;
}
void ListDestory(ListNode* plist)//链表的销毁
{
	assert(plist);
	ListNode* cur = plist->next;
	while (cur != plist)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(plist);
}

double_SList.c的代码块

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void SLinst1()
{
	ListNode* phead = ListCreate();
	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushBack(phead, 3);
	ListPushBack(phead, 4);
	ListPrint(phead);
	ListPopBack(phead);
	ListPopBack(phead);
	ListPrint(phead);
	ListPushFront(phead, 4);
	ListPushFront(phead, 3);
	ListPushFront(phead, 2);
	ListPushFront(phead, 1);
	ListPrint(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	//ListPopFront(phead);
	ListPrint(phead);
}
SLinst2()
{
	ListNode* phead = ListCreate();
	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushBack(phead, 3);
	ListPushBack(phead, 4);
	ListPrint(phead);
	ListInsert(phead, 4);
	ListPrint(phead);
	ListNode* s= ListFind(phead,3);
	printf("%d", s->data );
}
int main()
{
	
	/*SLinst1();*/
	SLinst2();
	return 0;
}

清晨白米稀饭.

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
带头双向循环链表增删查分析及代码实现（C语言实现）

带头双向循环链表分析及代码实现（C语言）一、带头双向循环链表结构二、代码2.1、创建一个带头双向循环链表2.2、开辟一个新的空间及打印链表2.3、链表尾插2.4、链表尾删2.5、链表头插2.6、链表头删2.7链表的查找2.8、在链表pos位置插入X2.9、删除pos位置上的数据2.10、链表的销毁三、完整代码块一、带头双向循环链表结构带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势
复制链接

扫一扫