数据结构-双向链表

文章目录

一、双向链表
- 1.双向链表的结构
- 2.双向链表的实现
二、顺序表与双向链表的优缺点分析
三、链表的分类
- 8种链表

一、双向链表

1.双向链表的结构

双向链表的全称是带头双向循环链表：

🍛🍛注意：这里的"带头"跟前面我们说的"头节点"是两个概念! 实际在前面的单链表阶段的称呼不严谨，但是为了能更好的理解就直接称为单链表的头节点。带头链表里的头节点，实际为"哨兵位"，哨兵位节点不存储任何有效元素，只是在这里"放哨"。

🏈 "哨兵位"存在的意义：
遍历循环链表避免死循环。

2.双向链表的实现

(1) 将双向链表的各种增删查改操作方法的声明放在List.h的头文件中：

c 复制代码

//List.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//定义双向链表的节点结构
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;
//初始化双向链表
//方法1
void LTInit1(LTNode** pphead);
//方法2
LTNode* LTInit2();

//打印链表数据
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);

//在指定位置之后插入节点
void LTInsertAfter(LTNode* pos, LTDataType x);

//删除指定位置的节点
void LTErase(LTNode* pos);

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

(2) 将方法的实现放在List.c的源文件中：

c 复制代码

//List.c
#include"List.h"
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = node->prev = node;
	return node;
}
void LTInit1(LTNode** pphead)
{
	*pphead = LTBuyNode(-1);//给双向链表创建一个哨兵位(头结点)
}
LTNode* LTInit2()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}
void LTPrint(LTNode* 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;
}
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = phead;
	newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
}
void LTPopBack(LTNode* phead)
{
	//链表必须有效且链表不能为空(也就是不能只有一个哨兵位)
	assert(phead && phead->next != phead);
	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	//删除节点
	free(del);
	del = NULL;
}
void LTPopFront(LTNode* phead)
{
	//链表必须有效且链表不能为空(也就是不能只有一个哨兵位)
	assert(phead && phead->next != phead);
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next->prev = phead;
	//删除节点
	free(del);
	del = NULL;
}
LTNode* LTFind(LTNode* phead,LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;//找到了就返回该节点的地址
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}
void LTInsertAfter(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	newnode->prev = pos;
	newnode->next = pos->next;
	pos->next->prev = newnode;
	pos->next = newnode;
}
void LTErase(LTNode* pos)
{
	//pos不能为phead,因为该函数的参数没有phead,所以不能参加校验
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}
void LTDestory(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

(3) 我们在test.c的源文件中进行各种方法的测试：

c 复制代码

#include"List.h"
void ListTest01()
{
	LTNode* plist = NULL;
	//初始化链表(链表中只有一个哨兵位)
	LTInit1(&plist);
	//LTNode* plist = LTInit2();
	//尾插节点
	LTPushBack(plist, 1);
	LTPrint(plist);
	LTPushBack(plist, 2);
	LTPrint(plist);
	LTPushBack(plist, 3);
	LTPrint(plist);
	//头插节点
	LTPushFront(plist, 4);
	LTPrint(plist);
	LTPushFront(plist, 5);
	LTPrint(plist);
	//尾删节点
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	//头删节点
	LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	//查找链表中的数据
	LTNode* find = LTFind(plist, 1);
	if (find == NULL)
	{
		printf("没找到!\n");
	}
	else
	{
		printf("找到了!\n");
	}
	//在指定位置之后插入数据
	LTInsertAfter(find, 66);
	LTPrint(plist);
	//删除指定位置的节点
	LTErase(find);
	find = NULL;
	//销毁链表
	LTPrint(plist);
	plist = NULL;
}
int main()
{
	ListTest01();
	return 0;
}

注意：上面的方法需要一个一个单独地进行调试，确保没有bug后，再进行下一个方法的测试。对于上面双向链表的各种增删查改操作函数的参数除了初始化链表的函数LTInit1传的是二级指针，其他函数都是传一级指针，这样做是为了保持接口的一致性，减少记忆的成本。当然也可以使用LTInit2函数，这样参数都传的是一级指针。
代码仓库：List

二、顺序表与双向链表的优缺点分析

三、链表的分类

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

8种链表

上面的带头不带头、单向双向和循环不循环解释如下图：
(1) 单向或者双向
(2) 带头或者不带头
(3) 循环或者不循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单向不带头不循环链表(单链表)和双向带头循环链表(双向链表)
🏀1.不带头单向不循环链表：结构简单，一般不会单独用来存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现得很多。
⚽2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。