目录
什么是双向链表：
定义：双向链表是由一个个节点组成的，而节点又是由存储的数据（可以是整型，浮点型，结构体类型等等），指向下一个节点的指针，和指向上一个节点的指针所组成的双向循环有头（简称双向链表）链表。（这里的有头指的是有哨兵位的链表，该哨兵位节点即为头结点）。
哨兵位可以在遍历这个链表的时候作为退出循环条件。
注意：哨兵位节点不能被删除，其节点地址也不能发生改变。
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}LTNode;这里将int重定义为LTDataType，方便以后存储其他类型（若要修改只需将第一行的int修改）。将struct ListNode重定义为LTNode方便以后使用。
next为该节点指向下一个节点的指针
prev为该节点指向上一个节点的指针
双向链表的操作：
申请一个双向链表的节点：
既然是链表，那么它就是由一个个节点组成的，那接下来看看是怎么申请节点的咯。
思路：
创造一个函数，形参为我所要存储的值。
用函数malloc申请一个空间取名为node，
接下来判断是否为空，若为空则警告返回，
然后让申请的这个节点自循环起来，最后返回。
OK！思路一出，直接开写：
LTNode* LTBuyNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
if(node == NULL)
{
perror("malloc fail");
return 1;
}
node->data = x;
node->prev = node->next = node;
return node;
}创建一个哨兵位：
方法一：以参数的形式初始化
这里使该节点的值为-1来代表哨兵位（也就是头结点）
为什么要传二级指针可以看我的上一篇《单链表的增删查改》有提到
void LTInit(LTNode** pphead)
{
*pphead = LTBuyNode(-1);
}方法二：以返回值的形式初始化：
LTNode* LTInit()
{
LTNode* phead = LTBuyNode(-1);
return phead;
}双向链表的增：
尾插：
思路：
先创建一个新节点node4，
然后修改4个链表中指针的指向即可，
先将newnode的prev指向原链表的最后一个节点（d3）（图里的操作2）
再将newnode的next指向哨兵位（也就是头结点）（图里的操作1）
再将原链表的最后一个节点（d3）的next指向newnode
最后将头结点的prev指向newnode即可
只需找到头结点的地址就可以找到双向链表的所有节点，所以形参只需传指向头节点的指针和所要插入的数据即可。
注意：这里3必须在4的上面 也就是说3（phead->prev->next = newnode;）必须相对于4（phead->prev = newnode;）先执行，
因为如果3在4的后面执行的话，此时3(phead->prev->next = newnode;)就会成为newnode->next = newnode,就会成为一个循环。
其余的都无所谓哦。
OK！思路一出直接开写。
void LTPushBack(LTNode* phead, LTDataType x)
{
assert(phead);//哨兵位不能为空
LTNode* newnode = LTBuyNode(x);
//phead phead->prev newnode
//先改变newnode的指向
newnode->prev = phead->prev;
newnode->next = phead;
phead->prev->next = newnode;//尾节点的指针
//头节点
phead->prev = newnode;
}头插：
注意：这里的头插并不是插在最前面，而是插在哨兵位（头节点）的后一个位置。
思路：
主体思路和尾插是差不多的，只是修改指针的指向不同。
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* newnode = LTBuyNode(x);
//先改变newnode的指向
newnode->next = phead->next;
newnode->prev = phead;
phead->next->prev = newnode;
phead->next = newnode;
}这里最后两行不能完全交换，如果交换了，那么就会找不到上图的d1，
当然，如果你就想要交换，那么可以稍微修改一下：
phead->next = newnode;
newnode->next->prev = phead;
原理就是通过newnode来找d1。
在pos位置之后插入数据：
思路：
这里的形参需要指向pos位置的指针，还有一个插入数据的值。
接着就只需要修改指针的指向就可以了。
void LTInsert(LTNode* pos, LTDataType x)
{
//传进来的pos不能为空
assert(pos);
LTNode* newnode = LTBuyNode(x);
newnode->next = pos->next;
newnode->prev = pos;
pos->next->prev = newnode;
pos->next = newnode;
}图中的那把x，是代码（pos->next->prev = newnode;）和代码（pos->next = newnode;）跑完后才会变的。
那么接下来看看特殊情况（在最后一个节点之后插入数据：）
直接根据上面写的代码画图：
可以看到，根据上面的代码，在最后一个节点完成插入是完全没问题的，
所以LTInsert方法包含了尾插。
双向链表的删：
头删：
思路：
首先这个链表的哨兵位不能指向自己，也就是除了哨兵位（头结点），还要有其他节点才能进行删除。
如果直接将phead->next那么就会找不到d1就会导致无法free掉，
所以可以新建一个指针（del）指向phead->next，然后对del进行操作即可。
void LTPopFront(LTNode* phead)
{
assert(phead && phead->next != phead);
LTNode* del = phead->next;
del->next->prev = phead;
phead->next = del->next;
free(del);
del = NULL;
}这里改变链表时顺序无关紧要，毕竟都可以找到。
尾删：
思路：主体大概和头删差不多
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;
}删除pos节点：
思路：
直接将pos的上一个节点的next指向pos的下一个节点
将pos的下一个节点的prev指向pos的上一个节点
最后free掉pos即可
void LTErase(LTNode* pos)
{
//这里的pos不能为哨兵位
assert(pos);
pos->next->prev = pos->prev;
pos->prev->next = pos->next;
free(pos);
pos = NULL;
}链表的销毁：
思路：
首先定义一个新指针（pcur）指向哨兵位的下一个节点，
然后遍历这个链表
结束条件：pcur != phead;
再循环中先定义一个next的指针指向pcur的下一个节点（这样才能释放pcur后找到pcur的下一个节点），然后释放pcur，最后让pcur指向它的next。
void LTDesTroy(LTNode* phead)
{
assert(phead);
LTNode* pcur = phead->next;
while (pcur != phead)
{
LTNode* next = pcur->next;
free(pcur);
pcur = next;
}
free(phead);
phead = NULL;
}双向链表的查找与打印：
查找：
思路：
遍历这个链表（和销毁差不多），如果等于要找的值就返回此时的指针，否则返回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 LTPrint(LTNode* phead)
{
LTNode* pcur = phead->next;
while (pcur != phead)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("\n");
}双向链表的修改：
思路：
通过LTFind函数找到此时我需要修改的位置，然后进行修改即可。
void LTChange(LTNode* pos, LTDataType x)
{
pos->data = x;
}完整代码：
text.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"LIst.h"
void ListTest01()
{
/*LTNode* plist = NULL;
LTInit(&plist);*/
LTNode* plist = LTInit();
//测试尾插
/*LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPrint(plist);*/
//测试头插
LTPushFront(plist, 5);
LTPrint(plist);
LTPushFront(plist, 4);
LTPrint(plist);
LTPushFront(plist, 3);
LTPrint(plist);
LTPushFront(plist, 2);
LTPrint(plist);
LTPushFront(plist, 1);
LTPrint(plist);
//LTPopBack(plist);
//LTPrint(plist);
//LTPopFront(plist);
//LTPrint(plist);
LTNode* find = LTFind(plist, 3);
//if (find == NULL)
//{
// printf("查找失败\n");
//}
//else {
// printf("找到了\n");
//}
//LTInsert(find, 3);
//LTPrint(plist);
//LTErase(find);
//LTPrint(plist);
LTChange(find, 30);
LTPrint(plist);
}
int main()
{
ListTest01();
return 0;
}List.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
//申请节点
//每申请一个节点都让它自循环起来
LTNode* LTBuyNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));
if (node == NULL)
{
perror("malloc");
return 1;
}
node->data = x;
node->next = node->prev = node;
return node;
}
//初始化
// 以参数形式初始化
//void LTInit(LTNode** pphead)
//{
// //给链表创建一个哨兵位
// *pphead = LTBuyNode(-1);
//}
//以返回值的形式初始化
LTNode* LTInit()
{
LTNode* phead = LTBuyNode(-1);
return phead;
}
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)
{
assert(phead);//哨兵位不能为空
LTNode* newnode = LTBuyNode(x);
//phead phead->prev newnode
//先改变newnode的指向
newnode->prev = phead->prev;
newnode->next = phead;
phead->prev->next = newnode;//尾节点的指针
//头节点
phead->prev = newnode;
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* newnode = LTBuyNode(x);
//先改变newnode的指向
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;
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;
del->next->prev = phead;
phead->next = del->next;
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)
{
//传进来的pos不能为空
assert(pos);
LTNode* newnode = LTBuyNode(x);
newnode->next = pos->next;
newnode->prev = pos;
pos->next->prev = newnode;
pos->next = newnode;
}
//删除pos节点
void LTErase(LTNode* pos)
{
//这里的pos不能为哨兵位
assert(pos);
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;
}
free(phead);
phead = NULL;
}
void LTChange(LTNode* pos, LTDataType x)
{
pos->data = x;
}List.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}LTNode;
//void LTInit(LTNode** pphead);
LTNode* LTInit();
//销毁
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);
//修改
void LTChange(LTNode* pos, LTDataType x);★声明：由于本人才开始学不久，水平有限，有错误或者不准确之处在所难免，发现恳望指正一起进步。
1919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
