双向链表专题

1. 双向链表的结构

注意：这里的  “带头”  跟前面我们说的  “头节点”  是两个概念，实际前面的在单链表阶段称呼不严
谨，但是为了同学们更好的理解就直接称为单链表的头节点。
带头链表里的头节点，实际为  “哨兵位”  ，哨兵位节点不存储任何有效元素，只是站在这里  “放哨
的”
“哨兵位”  存在的意义：
遍历循环链表避免死循环。

注意：哨兵位节点不能被删除，节点的地址也不能发生改变

链表由节点组成，那么节点包括什么？

 2. 实现双向链表

节点的结构实现：

struct ListNode
{
	int data;
	struct ListNode* next;
	struct ListNode* prev;
}

 

相比单向链表，多一个指向前一个节点的指针。

为了更好地理解双向链表的实现，我们先了解一下单链表和双向链表的差别：

单链表我们是手动创建的空链表；双向链表为空时，链表中只剩下一个头结点（哨兵位），所以我们创建的时候要先创建哨兵位。

List.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDataType;//给 int 重命名
//定义双向链表的结构
typedef struct ListNode
{
	int data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;


//声明双向链表中提供的方法

//初始化(哨兵位)
void LTInit(LTNode** pphead);
void LTDesTroy(LTNode* phead);//销毁

void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化到只有一个头结点的情况
//尾插
void LTPushBack(LTNode* phead，LTDataType x);

//头插
void LTPushFront(LTNode* phead，LTDataType x);

//尾删
void LTPopBack(LTNode* phead);

//头删
void LTPopFront(LTNode* phead);

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos
void LTErase(LTNode* pos);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

List.c

#include"List.h"

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

//申请节点
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;
	/*至于这里为什么不能是给NULL，因为双链表性质表明需要循环而必须使头结点自我循环*/

	return node;
}
//初始化
void LTInit(LTNode** pphead)
{
	//给双链表创建一个哨兵位
	*pphead = LTBuyNode(-1);
	/*哨兵位不存储有效值，但我们又有一个参数 x，所以我们随意放一个值（-1）*/
}
/*截至目前，我们初始化了一个哨兵位*/

//尾插
void LTPushBack(LTNode* phead，LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead（哨兵位） phead->prev（上图类d3位置哨兵位上一节点） newnode(新插入有效节点) 
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;

	phead->prev = newnode;
	/*原本是哨兵位自循环，现添加newnode节点，让三个相互连接*/
}
 
//头插
void LTPushFront(LTNode* phead，LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead（哨兵位） newnode(新插入有效节点) phead->next（上图类d1位置哨兵位下一节点）
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;

	phead->next = newnode;
}

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效且链表不能为空（只有一个哨兵位）
	assert(phead&& phead->next != phead);
    
	LTNode* del = phead->prev;
	//phead（哨兵位） del->prev（上图类d2位置删除的前一节点） del(要删除节点，上图d3为例)
	del->prev->next = phead;
	phead->prev = del->prev;

	//删除del节点
	free(del);
	del = NULL;
}

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

	LTNode* del = phead->next;

	//phead(哨兵位) del(要删除节点，上图d1为例) del->next（上图类d2位置删除的下一节点）
	phead->next->prev = phead;

	//删除del节点
	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;
}

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);

	//pos(上图类d2位置) newnode（要插入的新节点） pos->next（上图类d3，d2下一个位置）
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;

	pos->next = newnode;
}

//删除pos
void LTErase(LTNode* pos)
{
	//pos理论上来说不能为phead，但是没有参数phead，无法增加校验
	assert(pos);
	//pos->prev pos pos->next
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

//销毁
void LTDesTroy(LTNode* phead)
{
	assert(phead);

	LTNode* pcur = phead->next;
	while (pcur != phead);
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//此时pcur指向phead,而phead还未被销毁
	free(phead);
	phead = NULL;
}

test.c

#include"List.h"

void ListTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);

	/*LTPushBack(plist, 1);
	LTPrint(plist);
	LTPushBack(plist, 2);
	LTPrint(plist);
	LTPushBack(plist, 3);
	LTPrint(plist);

	LTPushFront(plist, 1);
	LTPrint(plist);
	LTPushFront(plist, 2);
	LTPrint(plist);
	LTPushFront(plist, 3);
	LTPrint(plist);*/


	//LTNode* find = LTFind(plist, 3);//以查找3为例
	//if (Find == NULL)
	//{
	//	printf("找到了\n");
	//}
	//else
	//{
	//	printf("找不到\n");
	//}

	LTInsert(find, 66);
	LTPrint(plist);

	LTErase(find);
	find = NULL;

	LTPrint(plist);
	LTDesTroy(plist);
	plist = NULL;

	/*LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);
	LTPrint(plist);
	LTPopBack(plist);*/
}
/*
LTErase和LTDestroy参数理论上要传二级，因为我们需要让形参的
改变影响到实参，但是为了保持接口一致性才传的一级
传一级存在的问题是，当形参phead置为NULL后，实参plist不会被
修改为NULL，因此解决办法是：调用完方法后手动将实参置为NULL
*/

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

3. 顺序表和双向链表的优缺点分析

*链表实际上是用  带头双向循环链表构成

*顺序表 插入扩容实际上 本身就有消耗，空间浪费，而链表插入 按需分配

 

原地扩容消耗更小，而异地扩容会另起地址扩容再删原地址，会消耗更多。但是扩容究竟是原地还是异地，不同程序，不同时间，不同大小都会不一样，也就是随机采用。

如果我们采用倍数扩增，就会面临空间浪费，但是节省时间浪费，总之顺序表在此方面有一定不足

*随机访问（用下标随机访问）上，链表不支持，相对会不方便。 

总结来说，双方就是互补的存在。