数据结构—双向链表（C语言实现）

---

前言

大家好哇！！欢迎来到我的博客！

在本博客，将讲解并实现双向链表。

双向链表的概念

对于双向链表，这里我们与之前的不带头非循环的单链表正好相反，将要实现的是带头循环的双向链表。

而此处的“带头”跟单链表中我们说的“头节点”是两个概念，实际前⾯在单链表阶段的称呼并不严谨，但是为了更好的理解就直接称为单链表的头节点。

带头链表⾥的头节点，实际上就是之前链表的分类中的的“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨的”
而“哨兵位”存在的意义：遍历循环链表避免死循环；同时在部分与链表相关的算法题中可以较大程度的降低题目的难度。
以下是双向链表的声明：

typedef int LTDataType;

typedef struct ListNode//定义双向链表
{
	LTDataType data;
	struct ListNode* prev;//指向上一个节点
	struct ListNode* next;//指向下一个节点
}LTNode;

可见，双向链表的节点分别包含指向上一个节点与指向下一个节点的指针。

双向链表的实现

与实现单链表不同的是，我们在对双向链表的方法传参时，传的是一级指针。
这时因为在对单链表进行增删查改的操作时，会涉及对链表的头节点（第一个节点）的更改的操作；而我们实现的是带头链表，创建了一个哨兵位节点，而这个哨兵位节点是不会改变的。
那么，接下来便是对于双向链表的实现：

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* prev;//指向上一个节点
	struct ListNode* next;//指向下一个节点
}LTNode;

//创建双向链表的节点
LTNode* LTBuyNode(LTDataType x);
//初始化双向链表
//void LTInit(LTNode** pphead);
LTNode* LTInit();
//销毁双向链表
void LTDestroy(LTNode* phead);
//打印双向链表
void LTPrint(LTNode* phead);
//双向链表判空
bool LTEmpty(LTNode* phead);

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

//双向链表的头插与头删
void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除指定位置的节点
void LTErase(LTNode* pos);
//双向链表的查找
LTNode* LTFind(LTNode* phead, LTDataType x);

List.c

注：在初始化双向链表时我们既可以直接在函数内创建哨兵位节点（此时需返回哨兵位节点的地址），也可以在函数外创建一个链表节点（此时需传二级指针），然后在函数内初始化为哨兵位节点。在初始化哨兵位节点我们应传一个相对无意义的值：

#include "List.h"

//初始化双向链表
//void LTInit(LTNode** pphead)
//{
//	*pphead = LTBuyNode(-1);
//}

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

//销毁双向链表
void LTDestroy(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	LTNode* del;
	while (pcur == phead)
	{
		del = pcur;
		pcur = pcur->next;
		free(del);
		del = NULL;
	}
	free(phead);
	phead = NULL;
}

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

//双向链表判空
bool LTEmpty(LTNode* phead)//判断链表是(true)否(false)为空
{
	assert(phead);
	if (phead->next == phead)
		return true;
	else
		return false;
}

//创建双向链表的节点
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 LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* prev = phead->prev;
	LTNode* newnode = LTBuyNode(x);
	newnode->next = phead;
	newnode->prev = prev;

	prev->next = newnode;
	phead->prev = 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 LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	LTNode* next = phead->next;
	newnode->next = next;
	newnode->prev = phead;

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

void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);//不能只有一个哨兵位
	LTNode* del = phead->next;
	phead->next = del->next;
	del->next->prev = phead;
}

//双向链表的查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead && phead->next != 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);
	newnode->prev = pos;
	newnode->next = pos->next;

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

//删除指定位置的节点
void LTErase(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

以上就是有关数据结构—双向链表的代码实现。

总结

讲解完了顺序表与链表的这两种数据结构。最后，让我们来比较一下顺序表与单链表的差异：

可见，顺序表与链表各有各的优劣。
如有错误，欢迎各位大佬指出。