1.双向链表的结构

1.1链表的简单介绍

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

1.2图文分析

2.实现双向链表

2.1链表的初始化

2.1.1初始化

//链表的初始化
void LTInit(LTNode** pphead)
{//哨兵位节点不存储任何的有效元素，只能站在这里“放哨的”，传递一个什么样的值都可以*pphead = LTBuyNode(-1);
}

2.1.2节点的申请

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

2.2链表的打印

2.2.1代码实现

//链表的打印
void LTPrint(LTNode* phead)
{//哨兵位不用打印，有效节点为哨兵位的下一个节点LTNode* pcur = phead->next;//本质还是遍历链表while (pcur != phead){printf("%d->", pcur->data);//pcur指针往下走pcur = pcur->next;}printf("\n");
}

2.2.2图文分析

2.3链表的尾插

2.3.1代码实现

//链表的尾插
void LTPushBack(LTNode* phead, LTDataType x)
{assert(phead);LTNode* newnode = LTBuyNode(x);//让newnode插在phead->prev(头结点的前一个节点)和phead之间newnode->prev = phead->prev;newnode->next = phead;phead->prev->next = newnode;phead->prev = newnode;//两者不能交换位置
}

2.3.2图文分析

2.4链表的头插

2.4.1代码实现

//链表的头插
void LTPushFront(LTNode* phead, LTDataType x)
{//头插：插在有效节点的前面，也就是头节点的后面assert(phead);LTNode* newnode = LTBuyNode(x);//把newnode节点插在phead和phead->next之间newnode->prev = phead;newnode->next = phead->next;phead->next->prev = newnode;phead->next = newnode;//这两行代码不能完全交换
}

2.4.2图文分析

2.5链表的尾删

2.5.1代码实现

//链表的尾删
void LTPopBack(LTNode* phead)
{//链表必须有效，且链表不能为空(只有一个哨兵位,自己指向自己)assert(phead && phead->next != phead);//要删除的节点LTNode* del = phead->prev;//要改变尾节点的前一个节点的指向 应该指向的是头节点（原本指向del的）del->prev->next = phead;//头结点的前一个节点就应该指向del->prevphead->prev = del->prev;//把尾节点内存释放掉,删除del节点free(del);del = NULL;
}

2.5.2图文分析

2.6链表的头删

2.6.1代码实现

//链表的头删
void LTPopFront(LTNode* phead)
{//链表必须有效，且链表不能为空(只有一个哨兵位,自己指向自己)assert(phead && phead->next != phead);//要删除的节点 -> 链表中第一个有效节点LTNode* del = phead->next;del->next->prev = phead;phead->next = del->next;//这两个可以交换//删除del节点free(del);del = NULL;
}

2.6.2图文分析

2.7在pos位置之后插入数据

2.7.1代码实现

//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* newnode = LTBuyNode(x);//也就是说，在pos与pos->next之间插入一个x节点newnode->next = pos->next;newnode->prev = pos;//既然是双向链表，肯定是有两个方向pos->next->prev = newnode;pos->next = newnode;
}

2.7.2图文分析

2.8删除pos位置节点

2.8.1代码实现

//删除pos位置节点
void LTErase(LTNode* pos)
{assert(pos);//就是把pos->prev和pos->next之间删除pos节点pos->next->prev = pos->prev;pos->prev->next = pos->next;//删除pos位置节点free(pos);pos = NULL;
}

2.8.2图文分析

2.9查找节点

2.9.1代码实现

//查找节点
LTNode* LTFind(LTNode* phead, LTDataType x)
{//就是自己传递的形参x 与链表中的有效数据进行对比，遍历链表LTNode* pcur = phead->next;while (pcur != phead){if (pcur->data == x){return pcur;}pcur = pcur->next;}//走到这，证明没有找到对应的数据，返回一个空指针return NULL;
}

2.10链表的销毁

2.10.1代码实现

//链表的销毁
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;
}

2.10.2图文分析

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

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