双向链表介绍-优快云博客

本文链接：https://blog.youkuaiyun.com/Yang_DX1/article/details/143507918

1.前言

首先总结一下链表的结构：实际中链表的结构非常多样。

1.单向或双向

2.带头(哨兵位)或不带头 （有哨兵位不用判空）

3.循环或者非循环

这些情况组合起来就有8种链表结构。

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

2.双链表的实现（带头双向循环链表）

双链表怎么定义呢？根据上图观察，每个结点需要两个指针变量，指向一前一后的结点；还需要有一个变量来存储想要存储的值；再加上之前说的定义结构为了适应不同的数据类型和方便使用，这样定义双链表的结构。

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;

2.1初始化

在写单链表的初始化之前，我们思考这样一个问题：为什么单链表没有初始化函数，双链表就要写初始化函数呢？这和具体的结构有关系。如果是单链表，定义了一个单链表类型的plist，有没有必要写函数对plist单独初始化呢？没有，因为单链表不带头，不循环，初始状态就是空的，因此直接赋值空指针就行了，没必要单独写函数。再多想想顺序表为什么单独写初始化函数，因为顺序表不是三两句话就可以完成初始化的，顺序表为空的重要标志是size=0，capacity看刚开始初始化时开了多少空间，有很多事情，因此交给一个函数来做。双链表初始化时什么样子呢？初始状态时只有一个哨兵位的头结点，为了体现循环，里面的两个指针不指向空，而是指向自己。这也有很多事情，因此交给一个函数来做。

双链表的初始化怎么实现呢？开始定义了一个双链表型的指针传给初始化函数，首先需要一个新的结点作为哨兵位的头，这里加一个BuyListNode函数来生成新的结点，以便后期使用方便；其次，因为形参的改变不影响实参，因此传二级指针，但为了保持后期代码风格的一致性，可以用返回值的方式来替代二级指针。

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

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

2.2尾插

对于双链表来说，每个结点的next指向下一个结点，prev指向上一个结点。尾结点的prev指向上一个结点，next指向头结点；哨兵位结点phead的next指向下一个结点，prev指向尾结点。那如何尾插呢？要想尾插首先需要找尾结点tail，生成一个新结点newnode存插入的值，然后改变尾部的链接关系即可（tail的next指向newnode，newnode的prev指向tail，newnode的next指向phead，phead的prev指向newnode）。这里找尾结点非常好找，哨兵位的prev就是尾结点。

就算双链表是最初的初始状态，也是一样的操作。

这里不需要传二级指针，因为改变的是结点间的链接关系，并没有改变结构体类型的指针变量。因为初始化后的指针一定指向哨兵位，不可能是空指针，所以需要断言。

2.3打印

为了方便看我们写的函数是否可以达成想要的效果，所以写一个打印函数。那怎么打印呢？初始化后的指针不是指向空的，而是指向哨兵位。因此定义一个cur指向哨兵位的下一个结点，依次遍历，遇到哨兵位时停止打印。

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

2.4尾删

尾删怎么删呢？通过哨兵位找尾，再找到尾的前一个保存，释放尾，让尾的前一个和哨兵位的链接关系改变。

尾删不能一直删，因此需要增加一个函数为了断言是不是为空，也就是看是不是初始状态。判断是不是为空其实就是看哨兵位的next是不是自己就可以了。

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

下面就可以实现尾删了。

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	tailPrev->next = phead;
	phead->prev = tailPrev;
	free(tail);
	tail = NULL;
}

2.5头插

怎么头插呢？先产生一个新结点，然后找到哨兵位的下一个结点，改变指针间的链接关系就可以完成头插了。但需要注意，如果保存了下一个结点的地址，就不需要考虑顺序了；如果没有保存需要考虑链接顺序，否则会找不到之后的结点。

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	//保存
	LTNode* first = phead->next;
	first->prev = newnode;
	newnode->next = first;
	newnode->prev = phead;
	phead->next = newnode;

	//不保存
	/*newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;*/
}

2.6头删

首先找到头并保存，然后保存头的下一个结点的地址，然后进行指针间的链接，最后释放头即可。这里也注意前面提到的断言问题。

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	LTNode* first = phead->next;
	LTNode* firstNext = first->next;

	firstNext->prev = phead;
	phead->next = firstNext;
	free(first);
	first = NULL;
}

2.7在pos之前插入

创立新的结点，不需要遍历找前一个，直接保存前一个并改变链接关系就可以了。这里注意pos不能为空。

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* posPrev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = posPrev;
	posPrev->next = newnode;
}

有了这个函数，尾插和头插的实现就可以复用这个函数了。

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


void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTInsert(phead->next, x);
}

2.8删除pos位置的值

不用遍历，直接找到pos的前一个和后一个保存起来，删除pos，再进行连接处理。因为形参的改变不影响实参，所以手动外部制空。

void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

有了这个函数，尾删尾插就可以复用了。

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTErase(phead->prev);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	
	LTErase(phead->next);
}

2.9查找

想要定位pos，也离不开查找，从phead的下一个结点开始遍历，再次遇到phead停止。找到想要的值后返回此处的地址，找不到就返回空。

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

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

3.完整代码


//LTNode.h


#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;


LTNode* LTInit();
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);
void LTInsert(LTNode* pos, LTDataType x);
void LTErase(LTNode* pos);
LTNode* LTFind(LTNode* phead, LTDataType x);


//LTNode.c



#include "List.h"


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

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

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

bool LTEmpty(LTNode* phead)
{
	assert(phead);
	return phead->next == phead;
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;*/
	LTInsert(phead, x);
}

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;
	//tailPrev->next = phead;
	//phead->prev = tailPrev;
	//free(tail);
	//tail = NULL;
	LTErase(phead->prev);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	//LTNode* newnode = BuyListNode(x);
	保存
	//LTNode* first = phead->next;
	//first->prev = newnode;
	//newnode->next = first;
	//newnode->prev = phead;
	//phead->next = newnode;

	//不保存
	/*newnode->next = phead->next;
	phead->next->prev = newnode;
	phead->next = newnode;
	newnode->prev = phead;*/
	LTInsert(phead->next, x);
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	/*LTNode* first = phead->next;
	LTNode* firstNext = first->next;

	firstNext->prev = phead;
	phead->next = firstNext;
	free(first);
	first = NULL;*/
	LTErase(phead->next);
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* posPrev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
	newnode->prev = posPrev;
	posPrev->next = newnode;
}

void LTErase(LTNode* pos)
{
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

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

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

//Test.c



#include "List.h"


void TestLTNode()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	LTPopBack(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPushFront(plist, 6);
	LTPushFront(plist, 7);
	LTPushFront(plist, 8);
	LTPrint(plist);
	LTPopFront(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTNode* pos = LTFind(plist, 2);
	LTInsert(pos, 11);
	LTPrint(plist);
}

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

4.补充

了解了双链表后，我们发现双链表相比顺序表弥补了许多顺序表不足的缺点。能不能说不掌握顺序表，只掌握双链表就可以了？肯定是不行的，实际上链表和顺序表是组合关系，相互配合，后面就可以慢慢体会到。下面来看看顺序表和链表的区别：

不同点	顺序表	链表
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持：O(1) (下标)	不支持：O(N)
任意位置插入或者删除元素	可能需要搬移元素，效率低 O(N)	只需修改指针指向
插入	动态顺序表，空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁
缓存利用率	高	低