数据结构——双向链表

数据结构——双向链表

一、引言：

在上一篇，我们学习了单链表，接下来我们要学习双向链表，在此之前，我们先要来了解一下链表的分类。

二、链表的分类：

链表的结构非常多样，以下情况组合起来就有8种链表结构：

链表说明：

• 在带头链表中，除了头结点，其他结点都储存有效的数据；头结点的作用是占位子，被称为“哨兵位结点”；

• 上一篇讲的单链表全称是：不带头单向不循环链表；双向链表全称是：带头双向循环链表；

• 双向链表结构相较于单链表来说结构要复杂，但是接口的实现上要比单链表简单很多。

三、双向链表

1.概念：

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针域，一个存放当前结点前一个结点的地址，一个存放当前结点后一个结点的地址。

2.结构：

定义双向链表结点的结构:

typedef int LTDataType;
typedef struct ListNode
{
    LTDataType data;
    struct ListNode*next;//指针保存下一个结点的地址
    struct ListNode*prev;//指针保存前一个结点的地址
}LTNode;

3.双向链表的实现

3.1创建节点

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

3.2初始化

LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

3.3尾插

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

	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = phead->prev;

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

3.4头插

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

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

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

3.5打印

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

3.6尾删

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

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

	free(del);
	del = NULL;
}

3.7头删

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

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

	free(del);
	del = NULL;
}

3.8查找

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

3.9在指定位置之后插入数据

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

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

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

3.10删除指定位置的数据

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

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

3.11.1销毁

void LTDesTroy(LTNode** pphead)
{
	assert(pphead && *pphead);
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		LTNode* Next = pcur->next;
		free(pcur);
		pcur = Next;
	}
	//销毁哨兵位结点
	free(*pphead);
	*pphead = NULL;
	pcur = NULL;
}

3.11.2销毁

void LTDesTroy2(LTNode* phead)
{    //传一级，测试时需要手动将plist置为NULL
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* Next = pcur->next;
		free(pcur);
		pcur = Next;
	}
	free(phead);
	phead = pcur = NULL;
}

第一个参传一级还是二级，要看pphead指向的结点会不会发生改变？

如果发生改变，那么pphead的改变要影响实参,传二级；

如果不发生改变，pphead不会影响实参,传一级.

四、顺序表与链表的不同

不同点	顺序表	链表（单链表）
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持；O(1)	不支持；O(N)
任何位置插入或者删除元素	可能需要搬移元素，效率低O(N)	只需要修改指针指向，O(1)
插入	动态顺序表，空间不够时需要扩容，可能造成空间浪费	没有容量的概念，按需申请释放，不存在空间浪费
应用场景	元素高效率存储+频繁访问	任何位置高效率的插入和删除

最后，感谢大家的阅读，希望这篇文章能够为你的数据结构之旅增添一份宝贵的知识。如果你有任何问题或想要分享你的经验，请在评论区留下你的想法。让我们继续在编程的道路上一起成长！