带头双向循环链表详解

原创于 2025-09-17 15:05:35 发布 · 929 阅读

15 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

数据结构

文章目录

一、初始化内容
二、动态申请结点
三、初始化链表
四、打印链表
五、尾插
六、尾删
七、头插
八、头删
九、计算大小
十、查找元素
十一、在pos位置插入结点
十二、删除pos位置结点
十三、销毁链表
十四、链表判空
十五、全部源码

一、初始化内容

所需文件

头文件->List.h
源文件->test.c
源文件->List.c

同样，我们首先要定义一个结点类型，与单向链表相比，双向链表的结点类型中需要多出一个前驱指针，用于指向前面一个结点，实现双向

typedef int LTDataType;//存储的数据类型
typedef struct ListNode
{
	LTDataType data;//数据域
	struct ListNode* prev;//前驱指针
	struct ListNode* next;//后继指针
}ListNode;

二、动态申请结点

//创建动态结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

三、初始化链表

我们需要一个初始化函数，对双向链表进行初始化，在初始化的过程中，需要申请一个头结点，头结点的前驱和后继指针都指向自己，使得链表一开始便满足循环
在这里插入图片描述

//初始化链表
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);//申请一个头节点，头节点不存储有效数据
	//起始时只有头节点，让它的前驱和后继都指向自己
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回头结点
}

四、打印链表

打印双向链表是从头结点的后一个结点处开始向后遍历并打印，直到遍历到头结点处时便停止遍历和打印(头结点数据不打印)

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

五、尾插

尾插，申请一个新结点，将新结点插入到头结点和头结点的前一个结点之间即可。因为链表是循环的，头结点的前驱指针直接指向最后一个结点，所以我们不必遍历链表找尾
在这里插入图片描述

//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);//申请一个结点
	ListNode* tail = phead->prev;//记录头结点的前一个结点的位置
	//建立新结点与头结点之间的双向关系
	phead->prev = newnode;
	newnode->next = phead;
	//建立新结点与tail结点之间的双向关系
	tail->next = newnode;
	newnode->prev = tail;
}

六、尾删

尾删，即释放最后一个结点，并建立头结点和被删除结点的前一个结点之间的双向关系即可
在这里插入图片描述

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->prev;//记录头结点的前一个结点
	ListNode* newtail = tail->prev;//记录tail结点的前一个结点
	//建立头结点与newtail结点之间的双向关系
	phead->prev = newtail;
	newtail->next = phead;
	free(tail);//释放tail结点，不需要置空是因为tail是局部变量
}

七、头插

头插，即申请一个新结点，将新结点插入在头结点和头结点的后一个结点之间即可
在这里插入图片描述

//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* tail = phead->next;//记录头结点的后一个结点位置
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next = newnode;
	tail->prev = newnode;
}

八、头删

头删，即释放头结点的后一个结点，并建立头结点与被删除结点的后一个结点之间的双向关系即可
在这里插入图片描述

//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->next;//记录头结点的后一个结点
	ListNode* newtail = tail->next;//记录tail结点的后一个结点
	phead->next = newtail;
	newtail->prev = phead;
	free(tail);
}

九、计算大小

获取链表中的元素个数，即遍历一遍链表，统计结点的个数（头结点不计入）并返回即可

//获取链表中的元素个数
int ListSize(ListNode* phead)
{
	assert(phead);
	int count = 0;
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

十、查找元素

给定一个值，在链表中寻找与该值相同的结点，若找到了，则返回结点地址；若没有找到，则返回空指(NULL)

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

十一、在pos位置插入结点

在指定位置插入结点，准确来说，是在指定位置之前插入一个结点。我们只需申请一个新结点插入到指定位置结点和其前一个结点之间即可
在这里插入图片描述

//在指定位置插入结点
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* before = pos->prev;//记录pos指向结点的前一个结点
	ListNode* newnode = BuyListNode(x);
	newnode->next = pos;
	newnode->prev = before;
	before->next = newnode;
	pos->prev = newnode;
}

十二、删除pos位置结点

删除指定位置结点，释放掉目标结点后，建立该结点前一个结点和后一个结点之间的双向关系即可
在这里插入图片描述

//删除指定位置结点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* before = pos->prev;
	ListNode* after = pos->next;
	before->next = after;
	after->prev = before;
	free(pos);
}

十三、销毁链表

销毁链表，从头结点的后一个结点处开始向后遍历并释放结点，直到遍历到头结点时，停止遍历并将头结点也释放掉

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

十四、链表判空

链表判空，即判断头结点的前驱或是后驱指向的是否是自己即可

//链表判空
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	//函数返回true表示链表为空，false表示链表非空
	return phead->next == phead;
}

十五、全部源码

List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>


typedef int LTDataType;//存储的数据类型
typedef struct ListNode
{
	LTDataType data;//数据域
	struct ListNode* prev;//前驱指针
	struct ListNode* next;//后继指针
}ListNode;

//创建结点
ListNode* BuyListNode(LTDataType x);

//初始化链表
ListNode* ListInit();

//打印链表
void ListPrint(ListNode* phead);

//尾插
void ListPushBack(ListNode* phead, LTDataType x);

//尾删
void ListPopBack(ListNode* phead);

//头插
void ListPushFront(ListNode* phead, LTDataType x);

//头删
void ListPopFront(ListNode* phead);

//获取链表中的元素个数
int ListSize(ListNode* phead);

//查找元素
ListNode* ListFind(ListNode* phead,LTDataType x);

//在指定位置插入结点
void ListInsert(ListNode* pos, LTDataType x);

//删除指定位置结点
void ListErase(ListNode* pos);

//销毁链表
void ListDestroy(ListNode* phead);

//链表判空
bool ListEmpty(ListNode* phead);

List.c

#include"List.h"

//创建动态结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

//初始化链表
ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);//申请一个头节点，头节点不存储有效数据
	//起始时只有头节点，让它的前驱和后继都指向自己
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回头结点
}

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

//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);//申请一个结点
	ListNode* tail = phead->prev;//记录头结点的前一个结点的位置
	//建立新结点与头结点之间的双向关系
	phead->prev = newnode;
	newnode->next = phead;
	//建立新结点与tail结点之间的双向关系
	tail->next = newnode;
	newnode->prev = tail;
}

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->prev;//记录头结点的前一个结点
	ListNode* newtail = tail->prev;//记录tail结点的前一个结点
	//建立头结点与newtail结点之间的双向关系
	phead->prev = newtail;
	newtail->next = phead;
	free(tail);//释放tail结点，不需要置空是因为tail是局部变量
}

//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* tail = phead->next;//记录头结点的后一个结点位置
	newnode->next = phead->next;
	newnode->prev = phead;
	phead->next = newnode;
	tail->prev = newnode;

}

//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListNode* tail = phead->next;//记录头结点的后一个结点
	ListNode* newtail = tail->next;//记录tail结点的后一个结点
	phead->next = newtail;
	newtail->prev = phead;
	free(tail);
}

//获取链表中的元素个数
int ListSize(ListNode* phead)
{
	assert(phead);
	int count = 0;
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

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

//在指定位置插入结点
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* before = pos->prev;//记录pos指向结点的前一个结点
	ListNode* newnode = BuyListNode(x);
	newnode->next = pos;
	newnode->prev = before;
	before->next = newnode;
	pos->prev = newnode;
}

//删除指定位置结点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* before = pos->prev;
	ListNode* after = pos->next;
	before->next = after;
	after->prev = before;
	free(pos);
}

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

//链表判空
bool ListEmpty(ListNode* phead)
{
	assert(phead);
	//函数返回true表示链表为空，false表示链表非空
	return phead->next == phead;
}

test.c

#include"List.h"

void TestList1()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);

	ListPopBack(plist);
	ListPrint(plist);

	ListPushFront(plist, 20);
	ListPrint(plist);
}

void TestList2()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);

	ListPopFront(plist);
	ListPrint(plist);

	ListSize(plist);
	printf("链表中的元素个数: %d\n", ListSize(plist));
}

void TestList3()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListNode* pos = ListFind(plist, 3);
	ListInsert(pos, 20);
	ListPrint(plist);
}

void TestList4()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListNode* pos = ListFind(plist, 3);
	ListErase(pos);
	ListPrint(plist);
}


int main()
{
	TestList4();
	return 0;
}

标签

#链表 #数据结构