双向带头循环链表(双向链表)的实现

目录

双向链表

List.h文件

List.c文件

Test.c文件

特别说明:

1.双向链表的初始化

方法一

方法二

2. LTInsert函数与LTInserAfter函数的传参

3.双向链表的销毁

方法一

方法二


双向链表

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* next;
	struct ListNode* prev;
}LTNode;

//双向链表的初始化

//方法一
//void LTInit(LTNode** pphead);
//方法二
LTNode* LTInit();

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

//尾插
//头结点不发生改变,传一级指针
void LTPushBack(LTNode* phead, LTDataType x);

//头插
void LTPushFront(LTNode* phead, LTDataType x);

//尾删
//头结点不可被删除,传一级指针
void LTPopBack(LTNode* phead);

//头删
void LTPopFront(LTNode* phead);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);

//在pos位置之前插入数据
void LTInsertAfter(LTNode* pos, LTDataType x);

//删除pos位置的数据
void LTErase(LTNode* pos);

//双向链表的销毁

void LTDestroy(LTNode** pphead);

List.c文件

#include"List.h"

//申请结点空间
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newNode = (LTNode*)malloc(sizeof(LTNode));
	if (newNode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newNode->data= x;
	//next和prev都指向自己才是循环,不能指向NULL
	newNode->next = newNode->prev = newNode;

	return newNode;
}

//判断链表是否为空
bool LTEmpty(LTNode* phead)
{
	//只有一个头结点的情况下,双向链表为空
	assert(phead);
	return phead->next == phead;
	//表达式正确就是返回true(即链表为空)
	//不正确就是返回false(即链表不为空)
}

//双向链表的初始化

//方法一
//void LTInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = LTBuyNode(-1);
//}

//方法二
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

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

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

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

	//时间复杂度O(1)
}

//头插
//(插在第一个有效结点的前面,头结点的后面)
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

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

	//时间复杂度O(1)
}

//尾删
//头结点不可被删除,传一级指针
void LTPopBack(LTNode* phead)
{
	assert(phead);

	//判断双向链表是否为空(不包括头结点)
	assert(!LTEmpty(phead));//不为空才可以继续

	LTNode* del = phead->prev;

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

	free(del);
	del = NULL;
}

//头删
void LTPopFront(LTNode* phead)
{
	assert(!LTEmpty(phead));

	LTNode* del = phead->next;
	phead->next = del->next;
	del->next->prev = phead;
	free(del);
	del = NULL;

	//时间复杂度O(1)
}

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			//找到了
			return pcur;
		}
		pcur = pcur->next;
	}
	//没找到
	return NULL;
}

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);

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

	//时间复杂度O(1)
}

//在pos位置之前插入数据
void LTInsertAfter(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);

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

	//时间复杂度O(1)
}

//删除pos位置的数据
void LTErase(LTNode* pos)
{
	assert(pos);

	//pos->prev  pos  pos->next
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
	pos = NULL;
}

//双向链表的销毁

//传二级指针可以实现——但是违背了窗口一致性
void LTDestroy(LTNode** pphead)
{
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(*pphead);
	*pphead = NULL;
}

//传一级指针——与前面的所有函数同步(降低记忆成本)
void LTDestroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

Test.c文件

#include"List.h"

 test01()
{
	//初始化双向链表
	
	//方法一
	//LTNode* plist = NULL;
	//LTInit(&plist);

	 //方法二
	 LTNode* plist = LTInit();

	 //尾插
	 LTPushBack(plist, 1);
	 LTPushBack(plist, 2);
	 LTPushBack(plist, 5);
	 LTPushBack(plist, 6);
	 LTPrint(plist);
	 
	 //头插
	 LTPushFront(plist, 3);
	 LTPushFront(plist, 4);
	 LTPrint(plist);
	 
	 //尾删
	 LTPopBack(plist);
	 LTPopBack(plist);
	 LTPrint(plist);
	 
	 //头删
	 LTPopFront(plist);
	 LTPopFront(plist);
	 LTPrint(plist);

	 //查找
	 LTNode* find1 = LTFind(plist, 2);
	/* if (find == NULL)
	 {
		 printf("未找到!\n");
	 }
	 else {
		 printf("找到了!\n");
	 }*/

	 //在pos位置之后插入数据
	 LTInsert(find1, 100);
	 LTPrint(plist);

	 //在pos位置之前插入数据
	 LTNode* find2 = LTFind(plist, 100);
	 LTInsertAfter(find2, 200);
	 LTInsertAfter(find2, 400);
	 LTPrint(plist);

	 //删除pos位置的数据
	 LTErase(find1);
	 LTErase(find2);

	 LTPrint(plist);

	 //销毁链表
	 
	 //传二级——违背窗口一致性
	 //LTDestroy(&plist);

	 //传一级——需要额外手动销毁头结点(推荐)
	 LTDestroy(plist);
	 plist = NULL;
}

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

特别说明:

1.双向链表的初始化

方法一

初始化一个头结点 plist 并置空,将plist的地址传入void型初始化函数LTInit中并用二级指针pphead接收。接下来会有一个误区,初学者可能会在这个时候直接令*pphead指针中的prev和next指向自身来完成初始化,因为此时还未申请空间,这会导致空指针的解引用从而引起空指针异常。正确的做法应该是定义一个申请空间的函数LTBuyNode并传初始化值,在该函数中定义结构体指针newnode并申请空间,再把初始化值赋给newnode->data,最后令prev和next指针指向自身,返回newnode并用*pphead接收即完成初始化。

方法二

定义一个LTNode*型的初始化函数LTInit,直接令头结点plist = LTInit(),而在初始化函数LTInit中,直接定义结构体指针phead接收LTBuyNode的返回值,最后将phead返回让plist接收,即完成初始化。此方法较为简单且不需要创建二级指针

因此个人较为推荐方法二

2. LTInsert函数与LTInserAfter函数的传参

指定位置(pos)之前/之后(LTInsert / LTInsertAfter) 插入数据,pos一般是依赖于LTFind函数返回的查找得到的值来决定的,如果查找不到则返回空指针NULL,而空指针无论传入LTInsert 还是 LTInsertAfter函数都会被断言assert中断。

3.双向链表的销毁

方法一

由于需要将头结点也释放掉,头结点发生了改变,因此第一反应肯定是传二级指针,然后循环进行销毁操作,最后释放掉头结点并置空。此方法逻辑上完全没有任何问题。

但需要注意的是,前面实现的所有函数都只是传了一级指针(默认初始化函数使用第二个方法),只有销毁用了二级指针,那么当我们分享这些功能实现的底层代码给下一个人接手实现某些项目的时候,调用这些函数需要记得销毁函数需要传二级指针,这是不是增加了记忆成本?万一调用销毁函数的时候错误传了一级指针,就很可能会出现问题,这就违背了窗口的统一性。

方法二

直接传一级指针,保证窗口的统一性,然后循环遍历进行销毁操作,但是发现最后会剩下一个头节点无法销毁,因为传的是一级指针(plist的“值”而非“址”),因此调用完销毁函数之后,还得单独对plist进行处理,手动将它置空(plist = NULL),销毁后的plist也将不再使用。

相比之下,第二种方法是较为合适的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值