【数据结构】双向链表
目录
数据结构之双向链表：：
List.h
List.c
1.创建返回链表的头结点
2.双向链表初始化
3.双向链表打印
4.双向链表销毁
5.双向链表尾插
6.双向链表尾删
7.双向链表头插
8.双向链表头删
9.双向链表查找
10.双向链表在pos前插入
11.双向链表删除pos位置
12.双向链表判空
13.双向链表长度
14.顺序表与链表的区别
数据结构之双向链表：：
List.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* ListInit();
void ListPrint(LTNode* phead);
void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
bool ListEmpty(LTNode* phead);
size_t ListSize(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);
//在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);
//删除pos位置
void ListErase(LTNode* pos);
void ListDestory(LTNode* phead);List.c
1.创建返回链表的头结点
LTNode* BuyListNode(LTDataType x)
{LTNode* node = (LTNode*)malloc(sizeof(LTNode));if (node == NULL){perror("malloc fail");exit(-1);}node->next = NULL;node->prev = NULL;
}2.双向链表初始化
LTNode* ListInit()
{LTNode* guard = (LTNode*)malloc(sizeof(LTNode));if (guard == NULL){perror("malloc fail");exit(-1);}guard->next = guard;guard->prev = guard;return guard;
}3.双向链表打印
void ListPrint(LTNode* phead)
{assert(phead);printf("guard<=>");LTNode* cur = phead->next;while (cur != phead){printf("%d<=>", cur->data);cur = cur->next;}printf("\n");
}4.双向链表销毁
//可以传二级 内部置空头结点
//建议:也可以考虑使用一级指针 让调用ListDestory的人将其置空 保持接口的一致性
void ListDestory(LTNode* phead)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);//phead = NULL;
}
5.双向链表尾插
void ListPushBack(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;
}6.双向链表尾删
void ListPopBack(LTNode* phead)
{assert(phead);//链表为空返回true 取反为假就报错assert(!ListEmpty(phead));//删掉最后一个结点 哨兵位变成自己指向自己 代码依然成立LTNode* tail = phead->prev;LTNode* prev = tail->prev;prev->next = phead;phead->prev = prev;free(tail);tail = NULL;
}7.双向链表头插
void ListPushFront(LTNode* phead, LTDataType x)
{assert(phead);//先链接newnode和phead->next结点之间的关系/*LTNode* newnode = BuyListNode(x);newnode->next = phead->next;phead->next->prev = newnode;phead->next = newnode;newnode->prev = phead;*///不关心先后顺序LTNode* newnode = BuyListNode(x);LTNode* first = phead->next;phead->next = newnode;newnode->prev = phead;newnode->next = first;first->prev = newnode;
}8.双向链表头删
void ListPopFront(LTNode* phead)
{assert(phead);//链表为空返回true 取反为假就报错assert(!ListEmpty(phead));//删到剩最后一个结点时 first指向最后一个结点 second指向哨兵位结点 删到最后哨兵位自己指向自己 代码依然成立LTNode* first = phead->next;LTNode* second = first->next;phead->next = second;second->prev = phead;free(first);first = NULL;
}9.双向链表查找
//双向链表的查找可以替代其修改函数
LTNode* ListFind(LTNode* phead, LTDataType x)
{assert(phead);LTNode* cur = phead->next;while (cur != phead){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}10.双向链表在pos前插入
//在pos之前插入
void ListInsert(LTNode* pos, LTDataType x)
{assert(pos);LTNode* prev = pos->prev;LTNode* newnode = BuyListNode(x);//prev newnode posprev->next = newnode;newnode->prev = prev;newnode->next = pos;pos->prev = newnode;
}
//ListInsert(phead,x)代替尾插
//ListInsert(phead->next,x)代替头插11.双向链表删除pos位置
//删除pos位置
void ListErase(LTNode* pos)
{assert(pos);LTNode* prev = pos->prev;LTNode* next = pos->next;prev->next = next;next->prev = prev;free(pos);//pos = NULL;置空并不起作用
}
//ListErase(phead->prev)代替尾删
//ListErase(phead->next)代替头删12.双向链表判空
bool ListEmpty(LTNode* phead)
{assert(phead);return phead->next == phead;
}13.双向链表长度
size_t ListSize(LTNode* phead)
{assert(phead);size_t n = 0;LTNode* cur = phead->next;while (cur != phead){++n;cur = cur->next;}return n;
}14.顺序表与链表的区别
| 不同点 | 顺序表 | 链表 |
| 存储空间上 | 物理上一定连续 | 逻辑上连续但是物理上不一定连续 |
| 随机访问 | 支持O(1) | 不支持O(N) |
| 任意位置插入或者删除元素 | 可能需要搬移元素，效率低O(N) | 只需修改指针指向 |
| 插入 | 动态顺序表，空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |
| 缓存利用率 | 高 | 低 |
备注：缓存利用率参考存储体系结构以及局部原理性
顺序表的优点：
1.尾插尾删的效率很高
2.可以用下标随机访问
3.相比链表结构 CPU高速缓存命中率更高
顺序表的缺点：
1.头部和中部插入效率低——O(N)
2.扩容时的性能消耗+扩容时的空间浪费
链表的优点：
1.任意位置插入删除效率很高——O(1)
2.按需申请释放
链表的缺点：
1.不支持随机访问
注：三级缓存被称为CPU周围的禁卫军
CPU执行指令不会直接访问内存
1.先看数据在不在三级缓存，在(命中)，直接访问
2.不在(不命中)，先加载到缓存，再访问
注：加载到缓存时，会将需要加载的位置开始的一段都加载进缓存,(加载多少取决于硬件)
由于顺序表的数据彼此之间的地址紧密联系 所以加载到高速缓存时命中率高 但链表不然 更可能会导致缓存污染
