数据结构_第四关：带头双向循环链表的实现

目录

1.带头双向循环链表

 2.带头双向循环链表的声明

3.接口函数的实现

1）创建返回链表的头结点

2）初始化

3） 打印

4）尾插

5）尾删

6）头插

7）头删

8）查找

9）在pos的前面进行插入

10）删除pos位置的结点

11）判空

12）判断链表的大小size

13）双向链表销毁

4.源代码（VS2022下编写）

5.顺序表和链表的区别

---

1.带头双向循环链表

当链表为NULL的状态是：

带头循环链表是逻辑最复杂的，但是实现起来是最简单的和实用的

 2.带头双向循环链表的声明

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

// 创建返回链表的头结点.
LTNode* BuyListNode(LTDataType x);

//初始化
LTNode* ListInit();

// 双向链表打印
void LTPrint(LTNode* phead);

// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);
// 双向链表尾删
void LTPopBack(LTNode* phead);

// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x);
// 双向链表头删
void LTPopFront(LTNode* phead);

// 双向链表查找
ListNode* LTFind(LTNode* phead, LTDataType x);

// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);

//判空
bool LTEmpty(LTNode* phead);

//判断链表的大小size
size_t LTSize(LTNode* phead);

// 双向链表销毁
void LTDestory(LTNode** phead);

3.接口函数的实现

1）创建返回链表的头结点

LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return newnode;
}

2）初始化

LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

由于初始化需要改变结构体，就需要用的二级指针

但因为有头结点的存在，其他接口函数上是不会改变结构体的，所以都用一级指针

为了统一好看一点，我们初始化也用一级指针

那我们就可以用返回值的方式进行处理

3） 打印

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

4）尾插

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* node = BuyListNode(x);

	node->next = phead;
	node->prev = phead->prev;

	phead->prev->next = node;
	phead->prev = node;
}

5）尾删

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* tail = phead->prev;

	phead->prev->prev->next = phead;
	phead->prev = phead->prev->prev;

	free(tail);
}

6）头插

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* node = BuyListNode(x);

	node->next = phead->next;
	node->prev = phead;

	phead->next = node;
	node->next->prev = node;

}

 

 要先将newnode链接到下一个结点，再将phead连接到newnode上

需要注意顺序

7）头删

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* first = phead->next;
	LTNode* second = first->next;

	/*phead->next = second;
	second->prev = phead;*/
	phead->next->next->prev = phead;
	phead->next = phead->next->next;

	free(first);

}

8）查找

ListNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

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

9）在pos的前面进行插入

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);

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

插入的实现可以直接让头插和尾插进行复用，

尾插的复用：LTInsert(phead,x);

头插的复用：LTInsert(phead->next,x);

再最后源代码里面有复用

10）删除pos位置的结点

void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* Prev = pos->prev;
	LTNode* Next = pos->next;
	free(pos);

	Prev->next = Next;
	Next->prev = Prev;
}

 删除的实现也可以让尾删和头删复用，

尾删的复用：LTErase(phead->prev);

头删的复用：LTErase(phead->next);

11）判空

bool LTEmpty(LTNode* phead)
{
	assert(phead);

	/*if (phead->next == phead)
		return true;
	else
		return false;*/

	return phead->next == phead;
}

12）判断链表的大小size

size_t LTSize(LTNode* phead)
{
	assert(phead);

	size_t size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

1.用哨兵位头节点data来记录size（有点小问题）
有的时候我们可以在哨兵位头节点里面的data存放size的大小，这样做的话，在进行插入和删除的时候，需要加上phead->data++和phead->data--
这需要用int的时候才能有，单如果是其他的，比如char，如果链表长度超过128就会出现问题

2.可以直接在结构里面加个size变量

3.直接遍历，如上：

13）双向链表销毁

void LTDestory(LTNode** pphead)
{
	assert(pphead);

	LTNode* cur = *pphead;
	cur = cur->next;
	while (cur != *pphead)
	{
		LTNode* Next = cur->next;
		free(cur);
		cur = Next;
	}

	free(*pphead);
	*pphead = NULL;
}

这里由于*pphead=NULL要改变结构体，所以需要用二级指针

这里想要整体统一的话，就需要外部进行置空，需要使用者进行

4.源代码（VS2022下编写）

#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;
}LTNode;

// 创建返回链表的头结点.
LTNode* BuyListNode(LTDataType x);

//初始化
LTNode* ListInit();

// 双向链表打印
void LTPrint(LTNode* phead);

// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);
// 双向链表尾删
void LTPopBack(LTNode* phead);

// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x);
// 双向链表头删
void LTPopFront(LTNode* phead);

// 双向链表查找
ListNode* LTFind(LTNode* phead, LTDataType x);

// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);

//判空
bool LTEmpty(LTNode* phead);

//判断链表的大小size
size_t LTSize(LTNode* phead);

// 双向链表销毁
void LTDestory(LTNode** phead);


//实现：

// 创建返回链表的头结点.
LTNode* BuyListNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return newnode;
}

//初始化
LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}


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

// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	//LTNode* node = BuyListNode(x);

	//node->next = phead;
	//node->prev = phead->prev;

	//phead->prev->next = node;
	//phead->prev = node;

	//复用到下面的插入当中：
	LTInsert(phead,x);
}

// 双向链表尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	/*LTNode* tail = phead->prev;

	phead->prev->prev->next = phead;
	phead->prev = phead->prev->prev;

	free(tail);*/

	//复用到Erase里面
	LTErase(phead->prev);
}

// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* node = BuyListNode(x);

	//node->next = phead->next;
	//node->prev = phead;

	//phead->next = node;
	//node->next->prev = node;
	//复用到下面的插入当中：
	LTInsert(phead->next, x);
}

// 双向链表头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

	///*phead->next = second;
	//second->prev = phead;*/
	//phead->next->next->prev = phead;
	//phead->next = phead->next->next;

	//free(first);

	//复用到Erase里面
	LTErase(phead->next);
}

// 双向链表查找
ListNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

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

// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);

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

// 双向链表删除pos位置的结点
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* Prev = pos->prev;
	LTNode* Next = pos->next;
	free(pos);

	Prev->next = Next;
	Next->prev = Prev;
}

//判空
bool LTEmpty(LTNode* phead)
{
	assert(phead);

	/*if (phead->next == phead)
		return true;
	else
		return false;*/

	return phead->next == phead;
}

//判断链表的大小size
size_t LTSize(LTNode* phead)
{
	assert(phead);

	size_t size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

// 双向链表销毁
void LTDestory(LTNode** pphead)
{
	assert(pphead);

	LTNode* cur = *pphead;
	cur = cur->next;
	while (cur != *pphead)
	{
		LTNode* Next = cur->next;
		free(cur);
		cur = Next;
	}

	free(*pphead);
	*pphead = NULL;
}

//测试

void text1()
{
	LTNode* phead = ListInit();

	LTPushBack(phead, 1);
	LTPushBack(phead, 2);
	LTPushBack(phead, 3);
	LTPushBack(phead, 4);
	LTPushBack(phead, 5);
	LTPushBack(phead, 6);
	LTPrint(phead);

	LTPopBack(phead);
	LTPopBack(phead);
	LTPopBack(phead);
	LTPrint(phead);

	LTPushFront(phead, 16);
	LTPushFront(phead, 15);
	LTPushFront(phead, 14);
	LTPushFront(phead, 13);
	LTPushFront(phead, 12);
	LTPushFront(phead, 11);
	LTPrint(phead);

	LTPopFront(phead);
	LTPopFront(phead);
	LTPopFront(phead);
	LTPrint(phead);

	LTNode* A = LTFind(phead, 3);
	if (A)
		printf("%d \n", A->data *= 10);
	LTPrint(phead);

	printf("size = %d\n", LTSize(phead));

	LTDestory(&phead);
}

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

5.顺序表和链表的区别

 顺序表:

• 优点:尾插尾删效率高,下标的随机访问快
• 缺点:空间不够需要扩容(扩容代价大);头部或者中间插入删除效率,需要挪动数据。

链表:

• 优点:需要扩容，按需申请释放小块节点内存;任意位置插入效率很高--O(1)。
• 缺点:不支持下标随机访问;