【初阶数据结构】双向链表 - 路途的美好风光（内含双链表的定义和代码实现）

前言

我已经在初阶数据结构这个栏目中已经给大家讲过了两种数据结构，分别是顺序表和单链表。那么在本文中，我继续的给大家讲解下一个数据结构——双向链表。

你可能会有一个疑惑，单链表我懂，但是这双向链表是啥？没事，接下来我就详细的帮助大家攻略难关。

1. 链表的分类

其实链表共有8种类型，请看下图：

其中我们常说的单链表，就是不带头单向不循环链表。而本文所讲的双向链表，就是带头双向循环链表。

这里我们需要避免一个误区：

我们平常在写代码时，通常会说给空的单链表创建一个头节点，其实这个说法是不对的，这么说只是为了方便大家想象和编写代码。

而头节点真正表示的是一个链表的首部，“头”。这个节点比较的特殊，它不存储有效的数值。我亲切的称呼它为“哨兵位”。那它有什么作用呢？在单链表的代码实现中，我们会常常苦于链表尾空链表的情况，为此还要专门给出一个判断条件。头节点节点就是让链表在物理结构上是不存在空链表的情况。

2. 双向链表的图示

双向链表的逻辑结构：

可以看到双向链表中的节点，包含了3个部分：数据、指向下一个节点的指针(后继指针)、指向上一个节点的指针(前驱指针)。

3. 双向链表的代码实现（重点）

3.1 List.h文件的内容

#pragma once

//#define NDEBUG
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>


//定义双向链表的节点
//在定义之前，我们说一下什么是双向链表？
//所谓的双向链表，其全称为有头双向循环链表。
typedef int LTDataType;

typedef struct LTNode
{
	LTDataType data;//数据
	struct LTNode* next;//存储下一个节点的地址
	struct LTNode* prev;//存储上一个节点的地址
}LTNode;

//下面是实现双向链表的各种方法(接口)

//初始化双向链表
void LTInit(LTNode** pphead);

//打印双向链表
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 LTInsert(LTNode* pos,LTDataType x);

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

//销毁双向链表
void LTDestory(LTNode* phead);//为了保持接口的一致性，这里我们采用一级指针。

3.2 List.c文件的内容(里面就是各种接口的实现)

#define _CRT_SECURE_NO_WARNINGS	

#include"List.h"

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

void LTInit(LTNode** pphead)
{
	LTNode* newnode = LTBuyNode(-1);//这步是为了创建头节点，又因为头节点不存储任何有效的值，所以值我们可以随便给
	*pphead = newnode;
}

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)
{
	LTNode* newnode = LTBuyNode(x);

	//进行尾插操作
	//phead phead->prev newnode

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

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

//头插（在第一个有效数据节点的前面插入）
void LTPushFront(LTNode* phead, LTDataType x)
{
	LTNode* newnode = LTBuyNode(x);

	//phead newnode phead->next

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

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

	//当链表中只有一个头结点时，不需要使用尾插方法。以上的方法就可以了
}


//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);


	//phead phead->prev
	//这样写可能不是那么容易理解，我们可以换一种形式来写
	/*phead->prev->next = phead;
	phead->prev = phead->prev->prev;*/

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

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

	LTNode* del = pos;
	//del->prev del del->next

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

	free(del);
	del = NULL;

}

//销毁双向链表
void LTDestory(LTNode* phead)
{
	LTNode* pcur = phead->next;

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

	phead = NULL;
	free(pcur);
	pcur = NULL;
}

以上就是双链表的代码实现。

如果觉得本文讲的还不错的话，麻烦给偶点个赞吧！！！