双向链表知识点（附源代码）

双向链表的特点

带头链表⾥的头结点，实际为“哨兵位”，哨兵位结点不存储任何有效元素，只是站在这⾥“放哨的”

例图解析

 双向链表与单链表的区别

双向链表：除了存储的数据外还有两个指针，具有头节点，还有循环的特点（因此就算链表只有一个节点的时候它前后节点是指向自己的而不是为null）。双向链表相比单链表在插入、删除和某些遍历操作上更高效。

单链表：可以有头节点也无头节点，不循环的。

如何构建一个双向链表

1.链表的初始化

双向链表有一个“标兵位”，这里新建的节点当作标兵位，这里有一点注意事项，主要是看进行传二级指针还是找有返回值这两种。如下是具体的代码实现。

void LTInit(LTNode** pphead)
{
    //创建一个头结点（哨兵位）
    pphead = LTBuyNode(-1);
}
//
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

2.尾插双向链表

尾插例图

尾插的时候一定要注意，不要先改变标兵位的指向，当标兵位置发生改变的时候后面节点的指向会出现指向错误。

3.头插双向链表

头插示意图

这里的头插，插入的是标兵位置后面，并不是首位置，图中可以看出首位置前面插入其实就是尾插而并不是头插。

4.头删双向链表

5.尾删双向链表

6.找到双向链表的指定位置

这里方法较为简单就不进行图像示意图，从“标兵位”后面开始寻找，找到所要寻找的元素进行返回就可以。

7.删除指定位置后面

通过找到的指定位置进行标记，然后通过标记位置对其后面进行插入，方法和尾插时的方法无异。

9.双向链表的销毁

双向表的销毁也是两种方法法一：不用二级指针进行传址，手动制空首元素，因为不进行二级指针传参这样形参的改变并不会改变实参，所以需要进行手动进行制空。

void LTDesTroy2(LTNode* phead)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* Next = pcur->next;
		free(pcur);
		pcur = Next;
	}
	free(phead);
	phead = pcur = NULL;
}

 总结

单链表适合简单的单向遍历操作，内存消耗小；而双链表适合需要双向遍历或者频繁涉及节点前驱访问的场景，但是相应地需要更多的内存空间来存储额外的指针。最后希望各位大佬进行指正，并留下一键三连（点赞，收藏，关注）。

原码

list.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef struct ListNode ListNode;
typedef  int LTDataType;
struct ListNode
{
	LTDataType data;
	ListNode* next;
	ListNode* pre;
};
// 创建返回链表的头结点.
ListNode* ListInit();
// 双向链表销毁
void ListDestory(ListNode* pHead);
//判断是否为空
bool ListEmpty(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
//双向链表的销毁
void ListDestory(ListNode** pos);

list.c

#include"List.h"
//开辟一个节点
ListNode* LTBuyNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode)); //开节点是开一个节点的空间
	if (newnode == NULL)
	{
		perror("fail!!!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->pre = newnode;
	return newnode;
}
//初始化
ListNode* ListInit()
{
	ListNode* pHead = LTBuyNode(-1);
	return pHead;
}
//判断是否为空
bool ListEmpty(ListNode* pHead)
{
	assert(pHead);
	return pHead->next == pHead;
}
//尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = LTBuyNode(x);

	newnode->next = pHead;
	newnode->pre = pHead->pre;
	pHead->pre->next = newnode;
	pHead->pre=newnode;
	
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);

	assert(!ListEmpty(pHead));
	ListNode* del = pHead->pre;
	pHead->pre = del->pre;
	del->pre->next = pHead;
	free(del);
	del = NULL;
}
//头插入
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = LTBuyNode(x); //带头节点的头插
	newnode->next = pHead->next;
	pHead->next->pre = newnode;

	pHead->next = newnode;
	newnode->pre = pHead;


}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	ListNode* del = pHead->next;
	pHead->next = del->next;
	del->next->pre = pHead;
	free(del);
	del = NULL;
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* pcur = pHead->next;
	while (pcur!= pHead)
	{
		
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	//pos前插入
	ListNode* newNode = LTBuyNode(x);
	newNode->next = pos;
	pos->pre->next = newNode;
	newNode->pre = pos->pre;
	pos->pre = newNode;
}
// 双向链表在pos的后面进行插入
void ListbackInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	//pos前插入
	ListNode* newNode = LTBuyNode(x);
	newNode->pre = pos;
	newNode->next = pos->next;
	pos->next->pre = newNode;
	pos->next = newNode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->pre->next=pos->next;
	pos->next->pre=pos->pre;
	free(pos);
	pos = NULL;

}
//双向链表的销毁
void ListDestory(ListNode** pHead)
{
	assert(pHead && *pHead);
	ListNode* pcur = (*pHead)->next;
	while (pcur != *pHead)
	{
		ListNode *next= pcur->next;
		free(pcur);
		pcur = next;
	}
	//对头节点进行释放
	free(*pHead);
	*pHead = NULL;
	pcur = NULL;
}
//打印
void ListPrint(ListNode* pHead)
{
	//此处一点要记得头节点其实是一个哨兵位
	ListNode* pcur = pHead->next;
	while (pcur != pHead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

test.c

#include"List.h"
void ListTest()
{
	ListNode* list = ListInit();
	//尾插
	ListPushBack(list, 1);
	ListPushBack(list, 2);
	ListPushBack(list, 3);
	ListPushBack(list, 4);
	ListPrint(list);
	//双向链表尾删
	ListPopBack(list);
	ListPrint(list);

	//头插入
	ListPushFront(list, 5);
	ListPushFront(list, 6);
	ListPushFront(list, 7);
	ListPrint(list);
	
	//双向链表的头删
	ListPopFront(list);
	ListPrint(list);

	// 双向链表查找
	ListNode* pos = ListFind(list, 6);
	if (pos == NULL)
	{
		printf("未找到！！！\n");
	}
	else
	{
		printf("找到了！！！\n");
	}

	// 双向链表在pos的前面进行插入
	ListInsert(pos, 66);
	ListPrint(list);

	//双向链表在pos的后面进行插入
	ListbackInsert(pos, 88);
	ListPrint(list);

	// 双向链表删除pos位置的节点
	ListErase( pos);
	ListPrint(list);
	ListDestory(&list);
}
int main()
{
	ListTest();
	return;
}