【数据结构】 双向链表

于 2024-03-14 17:27:01 发布
阅读量924 收藏 5
点赞数 25
文章标签： 数据结构 链表 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72651735/article/details/136709525
版权
本文详细介绍了双向链表的结构、接口函数实现（包括初始化、尾插、头插、尾删、头删、查找、插入和删除等）、以及如何在C语言中构建和操作双向链表。特别强调了哨兵位在提高效率中的作用。
摘要由CSDN通过智能技术生成

一、双向链表

        在我们学习单链表的过程中，发现单链表有个缺陷，在单链表尾插时，需要找到尾节点。在单链表尾删时需要找到尾节点前一个节点。这里的时间复杂度都为O(N)，而带头双向循环链表就完美的解决了这个问题。

        与单链表不同，双向链表多了一个prev指向了前面一个节点，最后尾也不指向NULL，而是指向了哨兵位。所以哨兵位的prev就直接能找到尾节点，简单且快速。

二、双向链表的实现

1.接口函数

这里有一个问题，我们学习单链表时，函数传参是二级指针，但是这里都是一级指针，为什么？

LTNode* LTInit();//初始化
void LTPushBack(LTNode* phead, LTDataType x);//尾插
void LTPopBack(LTNode* phead);//尾删
void LTPrint(LTNode* phead);//打印
void LTPushFront(LTNode* phead, LTDataType x);//头插
void LTPopFront(LTNode* phead);//头删
LTNode* LTFind(LTNode* phead, LTDataType x);//查找
void LTInsert(LTNode* pos, LTDataType x);//在pos之前插入
void LTErase(LTNode* pos);//删除pos的值
void LTDestroy(LTNode* phead);//销毁

因为双向链表是带头的，也就是哨兵位，哨兵位不存储有效数据并且无需改变哨兵位，只需改变链表的链接关系，所以不需要二级指针。

（当存在哨兵位时，头节点为哨兵位的后一个节点）

2.创建新节点

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("BuyLTNode is error\n");
		return;
	}
	newnode->data = x;
	return newnode;
}

3.初始化链表

初始化一个哨兵位节点，当链表为空时，哨兵位自己指向自己，形成一个环形链表

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

4.尾插

链表的尾也就是哨兵位的prev，在其后插入新节点，在进行链接。

单链表的尾插时间复杂度为O(N)，这里O(1)即可。

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

	//LTInsert(phead, x);
}

5.头插

头插即在哨兵位后一个节点插入新节点，再进行链接。

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	LTNode* newnode = BuyLTNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = cur;
	cur->prev = newnode;
	//LTInsert(phead->next, x);

}

6.尾删 

双向链表的尾删，只需找到尾节点的前一个节点之后，改变链接关系，最后释放尾节点即可。

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

	//LTErase(phead->prev);
}

7.头删

双向链表的头删，只需找到头节点的后一个节点，改变链接关系，释放头节点即可。

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

	//LTErase(phead->next);
}

8.查找

因为在双向循环链表中没有指向NULL节点的，所以在遍历链表时，我们需要把终止条件设置成

 != phead 此时即代表遍历结束。

LTNode* 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之前插入

找到pos的前一节点，改变pos的前一节点与新节点的链接即可。

在这个节点完成之后，我们可以把他用于头插和尾插，一行即可解决

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

尾插：LTInsert(phead, x);

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyLTNode(x);
	LTNode* front = pos->prev;
	front->next = newnode;
	newnode->next = pos;
	newnode->prev = front;
	pos->prev = newnode;
}

10.删除pos位的数据

找到pos前的pos后的数据，将其进行链接，然后释放pos即可。

同样可以用于头删与尾删。

这里还需加一个条件 assert(phead->next != phead); 防止删掉哨兵位。

头删：LTErase(phead->next);

尾删：LTErase(phead->prev);

void LTErase(LTNode* pos)
{
	LTNode* front = pos->prev;
	LTNode* behind = pos->next;
	front->next = pos->next;
	behind->prev = front;
	free(pos);
}

11.打印

打印整个链表，遍历链表当遍历到哨兵位时停止。

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

12.销毁

遍历释放链表，最后释放完哨兵位后，需要在主函数置空哨兵位地址，因为形参不能改变实参。

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;

	while (cur != phead)
	{
		LTNode* behind = cur;
		cur = cur->next;
		free(behind);
	}
	free(phead);
}

三、完整代码 

List.h

#pragma once
#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* LTInit();//初始化
void LTPushBack(LTNode* phead, LTDataType x);//尾插
void LTPopBack(LTNode* phead);//尾删
void LTPrint(LTNode* phead);//打印
void LTPushFront(LTNode* phead, LTDataType x);//头插
void LTPopFront(LTNode* phead);//头删
LTNode* LTFind(LTNode* phead, LTDataType x);//查找
void LTInsert(LTNode* pos, LTDataType x);//在pos之前插入
void LTErase(LTNode* pos);//删除pos的值
void LTDestroy(LTNode* phead);//销毁

 List.c

#define _CRT_SECURE_NO_WARNINGS
#include"List.h"

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("BuyLTNode is error\n");
		return;
	}
	newnode->data = x;
	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

	//LTInsert(phead, x);
}

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

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	LTNode* newnode = BuyLTNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = cur;
	cur->prev = newnode;
	//LTInsert(phead->next, x);

}

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

	//LTErase(phead->prev);
}

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

	//LTErase(phead->next);
}

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

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyLTNode(x);
	LTNode* front = pos->prev;
	front->next = newnode;
	newnode->next = pos;
	newnode->prev = front;
	pos->prev = newnode;
}

void LTErase(LTNode* pos)
{
	LTNode* front = pos->prev;
	LTNode* behind = pos->next;
	front->next = pos->next;
	behind->prev = front;
	free(pos);
}

void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;

	while (cur != phead)
	{
		LTNode* behind = cur;
		cur = cur->next;
		free(behind);
	}
	free(phead);
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include"List.h"

test1()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);
	
	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPrint(plist);
}

test2()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPrint(plist);

	LTPopFront(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);
}

test3()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	LTPushFront(plist, 8);
	LTPushFront(plist, 9);
	LTPrint(plist);

	LTNode* node = LTFind(plist, 8);
	if (node)
	{
		LTInsert(node, 99);
		LTPrint(plist);
		LTErase(node);
		LTPrint(plist);
	}
	LTDestroy(plist);
	plist = NULL;
}

int main()
{
	test3();

	return 0;
}

S_WEAN
关注
  • 25
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值