数据结构——带头双向循环链表实现

目录

前言

一、结构介绍

二、增删查改的实现

1.在某一位置前插入数据

2.头插

3.尾插

4.删除某一位置的节点

5.头删

6.尾删

7.查找

8.打印

9.销毁

三、完整项目代码

1.头文件(List.h)

2.函数文件(List.c)

3.主函数测试文件(test.c)


前言

在学习数据结构过程中,我们经常要用到顺序表和链表。顺序表的优点是可以随机访问,缺点是增删效率低。链表恰好弥补了顺序表的缺点,但是不能随机访问,而且代码比较麻烦。因为在进行插入删除操作时,我们必须考虑链表为空和不为空两种情况。除此之外,想要访问当前节点的上一个节点,就必须把链表再遍历一遍,降低了运行速度。那么,有没有有一种可能,链表也能非常方便地插入、删除、找前后节点呢?这就是本文要为大家介绍的,带头双向循环链表。

一、结构介绍

我们从单链表开始探索:

单链表的节点由两部分组成,即存储的数据、指向下一个节点的指针。

数据结构——带头双向循环链表实现_第1张图片

 用代码定义如下:

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

这种结构是单向的,不能从后往前找,于是可以想到,在结构体中再加上一个指针,用来指向前一个节点,这样我们的链表就变成了双向链表。

 代码定义如下:

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
    struct SListNode* prev;
}SListNode;

通过指针prev即可倒回去找前面的节点。这样能在一定程度上减少麻烦。

当然,这种情况下,进行插入操作时,还需要顾及链表是否为空的情况。两种情况操作不同,会增加代码量。因此,我们可以增加一个头节点head,不存储数据,只是占一个位置,我们称之为哨兵位。这样,即使链表为空,也有一个节点,可以进行访问next指针的操作。

以下是链表创建过程:

ListNode* BuyLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

ListNode* ListCreate()
{
	ListNode* L = BuyLTNode(-1);
	L->next = NULL;
	L->prev = NULL;
	return L;
}

简单解释:创建一个新的节点,让其中存储-1(随便什么都行),prev和next指针置为空,这个节点是头节点,不存储实际数据,但是在插入时能简化操作。

头插方便了,但是如果要在尾部插入呢?你需要先创建一个指针,遍历链表,找到链表尾部,然后再插入,好麻烦那!别急,我们的带头双向链表继续升级,带头双向循环链表,就可以解决这个问题。

数据结构——带头双向循环链表实现_第2张图片

 以下是链表创建过程:

ListNode* BuyLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

ListNode* ListCreate()
{
	ListNode* L = BuyLTNode(-1);
	L->next = L;
	L->prev = L;
	return L;
}

最初创建头节点时,头节点两个指针可以自己指向自己。

二、增删查改的实现

1.在某一位置前插入数据

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyLTNode(x);
	newnode->prev = pos->prev;
	pos->prev->next = newnode;
	newnode->next = pos;
	pos->prev = newnode;
}

在这里,不管是在哪里插入,都可以用这段代码,因为任何节点之间的结构都是一样的。可以配合另一个寻找节点的函数使用,先找到想要的节点,再在前面插入。

2.头插

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead->next, x);
}

正因这种结构良好的兼容性,插入代码可以直接用来为头插函数服务。而在有头节点的情况下,只需通过头节点找next即可找到插入位置。

3.尾插

void ListPushBack(ListNode* pHead, LTDataType x)
{
    assert(pHead);
	ListInsert(pHead, x);
}

 插入代码也可以直接用来为尾插函数服务。而尾插是在链表最后插入,但是对于循环链表,链表的头即是尾,尾即是头,只需传头节点指针,头节点的前一个位置,就是链表尾。是不是巨方便?

4.删除某一位置的节点

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

这里由于要删除节点,需要断开前后联系,可以先创建临时指针表示前后的节点,方便后面操作。

不管是哪里删除,都可以用这段代码。可以配合查找函数使用。

5.头删

void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->next);
}

有了插入函数,我们可以直接在头删函数中使用。注意头删可不是删除头节点,头节点只是占个位置,招你惹你了?删的是头节点的下一个位置,这才是第一个元素。

6.尾删

void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->prev);
}

插入函数在尾删也是可以直接用滴!想找尾?头节点的前一个就是!!!是不是巨方便?

7.查找

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

当然了,不管是是顺序表还是链表,要查找,他都得遍历。从头开始,找到那个存x的结点,返回它的地址就行。

8.打印

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

你别说,没这个函数其实也行,但是不好测试。这个函数主要是为了能在测试时把链表显示出来,让你知道,你成功辣!

9.销毁

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		ListNode* prev = cur;
		cur = cur->next;
		free(prev);
	}
	free(pHead);
}

虽然退出程序操作系统会自动回收空间,但是如果这段代码用来做其他项目的接口,可能要运行很长时间,内存泄漏可是不好的。用完要销毁。每个节点都要free掉哦。

三、完整项目代码

1.头文件(List.h)

#include
#include
#include
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

2.函数文件(List.c)

#include "List.h"

ListNode* BuyLTNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

ListNode* ListCreate()
{
	ListNode* L = BuyLTNode(-1);
	L->next = L;
	L->prev = L;
	return L;
}

void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		ListNode* prev = cur;
		cur = cur->next;
		free(prev);
	}
	free(pHead);
}

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		printf("%d<==>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void ListPushBack(ListNode* pHead, LTDataType x)
{
	ListInsert(pHead, x);
}

void ListPopBack(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->prev);
}

void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListInsert(pHead->next, x);
}

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyLTNode(x);
	newnode->prev = pos->prev;
	pos->prev->next = newnode;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListErase(pHead->next);
}

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

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

3.主函数测试文件(test.c)

#include"List.h"
int main()
{
	ListNode* pHead = NULL;
	pHead = ListCreate();
	printf("尾插1、2、3、4\n");
	ListPushBack(pHead, 1);
	ListPushBack(pHead, 2);
	ListPushBack(pHead, 3);
	ListPushBack(pHead, 4);
	ListPrint(pHead);
	printf("尾删一次\n");
	ListPopBack(pHead);
	ListPrint(pHead);
	printf("头插5、6、7、8\n");
	ListPushFront(pHead, 5);
	ListPushFront(pHead, 6);
	ListPushFront(pHead, 7);
	ListPushFront(pHead, 8);
	ListPrint(pHead);
	printf("头删一次\n");
	ListPopFront(pHead);
	ListPrint(pHead);
	printf("删除元素为1的节点\n");
	ListErase(ListFind(pHead, 1));
	ListPrint(pHead);
	printf("销毁链表\n");
	ListDestory(pHead);
	pHead = NULL;
	return 0;
}

记得最后将pHead制空,因为函数内部不能改变原指针,需要在外部制空,这样就永远找不到那份空间了。

这个测试代码可以很好地测试一下你写的函数是否可以运行起来(不包括函数的提醒报错功能,因为运行不起来不容易看结果)。那么,我们测试运行以下,结果如下:

数据结构——带头双向循环链表实现_第3张图片

 看来我们的代码非常成功。带头双向循环链表真是太好用辣!

你可能感兴趣的:(数据结构,链表,数据结构)