文章目录
前言
前面我们学习了顺序表和不带头单向不循环链表，还是不太懂的老铁，可以去把前面的文章看看，今天我们要深入了解的是另一个实现生活中使用很频繁的一种链表：带头双向循环链表。
1.双向链表的结构及定义
为了大家更好的理解，我把那个指向给大家画出来了。后面我们的图解都是用上图演示哈。
typedef int LTDataType;//类型重定义，方便修改类型
typedef struct ListNode
{
LTDataType val;
struct ListNode* prev;//指针保存上⼀个结点的地址（前驱指针）
struct ListNode* next;//指针保存下⼀个结点的地址（后继指针）
}LTNode;
插入：怕大家把第一个存储数据的结点和带头的头结点搞混了，再解释一下
不带哨兵位的头结点
不带哨兵位的头结点，在链表的系列操作函数中可能会修改到指向存储有效数据的第一个结点的指针plist，对在第一元素结点前插入结点和删除第一结点时，我们要用二级指针去改变plist的指向。
带哨兵位的头结点
这个结点不存储有效数据，链表的系列操作函数永远不会修改到指向存储有效数据的第一个结点的指针plist，因为拥有这个带哨兵位的头结点，对在第一元素结点前插入结点和删除第一结点时，其操作与其他结点的操作就统一了。这个带哨兵位的头结点看起来简单一点，但是后续学习的哈希桶、邻接表做子结构都是不带头，另外这种结构在笔试⾯试中出现很多。大部分OJ题也是不带哨兵位的头结点的。
2.带头+双向+循环链表接口实现
新建一个工程：
List.h:
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;//类型重定义，方便修改类型
typedef struct ListNode
{
LTDataType val;
struct ListNode* prev;//指针保存上⼀个结点的地址（前驱指针）
struct ListNode* next;//指针保存下⼀个结点的地址（后继指针）
}LTNode;
//动态申请一个结点
LTNode* CreatLTNode(LTDataType x);
//初始化双向链表
LTNode* LTInit();
// 双向链表打印
void LTPrint(LTNode* phead);
// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);
// 双向链表尾删
void LTPopBack(LTNode* phead);
// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x);
// 双向链表头删
void LTPopFront(LTNode* phead);
// 双向链表查找x
LTNode* LTFind(LTNode* phead, LTDataType x);
// 双向链表在pos位置前插入x
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
//求双向链表的元素个数
int LTSize(LTNode* phead);
//判断双向链表是否为空
int LTEmpty(LTNode* phead);
// 双向链表销毁
void LTDestroy(LTNode* phead);
2.1动态申请一个结点
//动态申请一个结点
LTNode* CreatLTNode(LTDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->val = x;
newnode->prev = NULL;
newnode->next = NULL;
return newnode;
}
2.2初始化双向链表
这里本来是要用二级指针来改变plist的指向的，但是我们整个接口实现都不会用到二级指针，为了整体的美观，这里我们选择用返回值来接收，如果不懂的话，可以看上篇单链表那里讲了链表的传参问题。
//初始化双向链表
LTNode* LTInit()
{
LTNode* phead = CreatLTNode(-1);//这里必须要传一个值的，随便传了一个不用理会
phead->next = phead;
phead->prev = phead;
return phead;
}
2.3双向链表打印
// 双向链表打印
void LTPrint(LTNode* phead)
{
assert(phead);
printf("哨兵位<=>");
LTNode* pcur = phead->next;//哨兵位不存储数据，要从phead的下一个结点进行遍历
while (pcur != phead)
{
printf("%d<=>", pcur->val);
pcur = pcur->next;
}
printf("\n");
}
2.4双向链表尾插
// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* newnode = CreatLTNode(x);
LTNode* ptail = phead->prev;
//头phead 尾ptail 插newnode
ptail->next = newnode;
newnode->prev = ptail;
newnode->next = phead;
phead->prev = newnode;
}
2.5双向链表尾删
// 双向链表尾删
void LTPopBack(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTNode* ptail = phead->prev;
LTNode* ptailPrev = ptail->prev;
free(ptail);
//tail = NULL;
ptailPrev->next = phead;
phead->prev = ptailPrev;
}
2.6双向链表头插
// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
//LTNode* newnode = CreatLTNode(x);
//newnode->next = phead->next;
//phead->next->prev = newnode;
//newnode->prev = phead;
//phead->next = newnode;
LTNode* first = phead->next;
LTNode* newnode = CreatLTNode(x);
newnode->next = first;
first->prev = newnode;
phead->next = newnode;
newnode->prev = phead;
}
2.7双向链表头删
// 双向链表头删
void LTPopFront(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTNode* first = phead->next;
LTNode* second = first->next;
phead->next = second;
second->prev = phead;
free(first);
//first = NULL;
}
2.8双向链表查找x
这里查找也可以在test.c中进行修改x值，也可以和LTErase一起使用。
// 双向链表查找x
LTNode* LTFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* pcur = phead->next;//哨兵位不存储数据，要从phead的下一个结点进行遍历
while (pcur != phead)
{
if (pcur->val == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
2.9双向链表在pos位置前插入x
// 双向链表在pos位置前插入x
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* posPrev = pos->prev;
LTNode* newnode = CreatLTNode(x);
posPrev->next = newnode;
newnode->prev = posPrev;
newnode->next = pos;
pos->prev = newnode;
}
2.10双向链表删除pos位置的结点
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos)
{
assert(pos);
LTNode* posPrev = pos->prev;
LTNode* posNext = pos->next;
posPrev->next = posNext;
posNext->prev = posPrev;
free(pos);
//pos = NULL;
}
2.11求双向链表的元素个数
//求双向链表的元素个数
int LTSize(LTNode* phead)
{
assert(phead);
int size = 0;
LTNode* pcur = phead->next; //哨兵位不存储数据，要从phead的下一个结点进行遍历
while (pcur != phead) //遍历链表
{
size++;
pcur = pcur->next;
}
return size;
}
2.12判断双向链表是否为空
//判断双向链表是否为空
int LTEmpty(LTNode* phead)
{
return phead->next == phead ? 0 : 1;//三字母词，为空则返回0；不为空返回1
}
2.13双向链表销毁
这里需要二级指针才能置空phead，但是我为了整体的美观，我们这里每次使用完后，在函数外面置空 plist。
// 双向链表销毁
void LTDestroy(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
free(phead);
//phead = NULL;
}
优化代码
其实我们一开始实现LTInsert和LTErase就ok了这样我们实现头插、头删、尾插、尾删都直接调用这两个函数即可了
// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
LTInsert(phead, x);
}
// 双向链表尾删
void LTPopBack(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTErase(phead->prev);
}
// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTInsert(phead->next, x);
}
// 双向链表头删
void LTPopFront(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTErase(phead->next);
}
下面我就放优化后的完整代码咯。
完整代码（包括测试代码）
SList.h:
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int LTDataType;//类型重定义，方便修改类型
typedef struct ListNode
{
LTDataType val;
struct ListNode* prev;//指针保存上⼀个结点的地址（前驱指针）
struct ListNode* next;//指针保存下⼀个结点的地址（后继指针）
}LTNode;
//动态申请一个结点
LTNode* CreatLTNode(LTDataType x);
//初始化双向链表
LTNode* LTInit();
// 双向链表打印
void LTPrint(LTNode* phead);
// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x);
// 双向链表尾删
void LTPopBack(LTNode* phead);
// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x);
// 双向链表头删
void LTPopFront(LTNode* phead);
// 双向链表查找x
LTNode* LTFind(LTNode* phead, LTDataType x);
// 双向链表在pos位置前插入x
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
//求双向链表的元素个数
int LTSize(LTNode* phead);
//判断双向链表是否为空
int LTEmpty(LTNode* phead);
// 双向链表销毁
void LTDestroy(LTNode* phead);
SList.c:
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
//动态申请一个结点
LTNode* CreatLTNode(LTDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->val = x;
newnode->prev = NULL;
newnode->next = NULL;
return newnode;
}
LTNode* LTInit()
{
LTNode* phead = CreatLTNode(-1);//这里必须要传一个值的，随便传了一个不用理会
phead->next = phead;
phead->prev = phead;
return phead;
}
// 双向链表打印
void LTPrint(LTNode* phead)
{
assert(phead);
printf("哨兵位<=>");
LTNode* pcur = phead->next;//哨兵位不存储数据，要从phead的下一个结点进行遍历
while (pcur != phead)
{
printf("%d<=>", pcur->val);
pcur = pcur->next;
}
printf("\n");
}
// 双向链表尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
assert(phead);
LTInsert(phead, x);
}
// 双向链表尾删
void LTPopBack(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTErase(phead->prev);
}
// 双向链表头插
void LTPushFront(LTNode* phead, LTDataType x)
{
assert(phead);
LTInsert(phead->next, x);
}
// 双向链表头删
void LTPopFront(LTNode* phead)
{
assert(phead);
assert(phead->next != phead);
LTErase(phead->next);
}
// 双向链表查找x
LTNode* LTFind(LTNode* phead, LTDataType x)
{
assert(phead);
LTNode* pcur = phead->next;//哨兵位不存储数据，要从phead的下一个结点进行遍历
while (pcur != phead)
{
if (pcur->val == x)
{
return pcur;
}
pcur = pcur->next;
}
return NULL;
}
// 双向链表在pos位置前插入x
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* posPrev = pos->prev;
LTNode* newnode = CreatLTNode(x);
posPrev->next = newnode;
newnode->prev = posPrev;
newnode->next = pos;
pos->prev = newnode;
}
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos)
{
assert(pos);
LTNode* posPrev = pos->prev;
LTNode* posNext = pos->next;
posPrev->next = posNext;
posNext->prev = posPrev;
free(pos);
//pos = NULL;
}
//求双向链表的元素个数
int LTSize(LTNode* phead)
{
assert(phead);
int size = 0;
LTNode* pcur = phead->next; //记录第一个节点
while (pcur != phead) //遍历链表
{
size++;
pcur = pcur->next;
}
return size;
}
//判断双向链表是否为空
int LTEmpty(LTNode* phead)
{
return phead->next == phead ? 0 : 1;//三字母词，为空则返回0；不为空返回1
}
// 双向链表销毁
void LTDestroy(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
free(phead);
//phead = NULL;
}
test.c:
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void LTtest1()
{
LTNode* plist = LTInit();
LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPushBack(plist, 5);
LTPrint(plist);
LTPopBack(plist);
LTPrint(plist);
LTPushFront(plist, 29);
LTPrint(plist);
LTPopFront(plist);
LTPrint(plist);
LTPopFront(plist);
LTPrint(plist);
LTPopFront(plist);
LTPrint(plist);
LTPopFront(plist);
LTPrint(plist);
LTPopFront(plist);
LTPrint(plist);
//LTPopFront(plist);
//LTPrint(plist);
//主动置空
LTDestroy(plist);
plist = NULL;
}
void LTtest2()
{
LTNode* plist = LTInit();
LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPushBack(plist, 5);
LTPrint(plist);
LTPopBack(plist);
LTPrint(plist);
LTPushFront(plist, 29);
LTPrint(plist);
//查找的同时可以修改
LTNode* pos = LTFind(plist, 4);
if (pos)
{
pos->val *= 20;
}
LTPrint(plist);
LTInsert(pos, 200000);
LTPrint(plist);
LTInsert(plist, 9);
LTPrint(plist);
//主动置空
LTDestroy(plist);
plist = NULL;
}
void LTtest3()
{
LTNode* plist = LTInit();
LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPushBack(plist, 5);
LTPrint(plist);
LTPopBack(plist);
LTPrint(plist);
LTPushFront(plist, 29);
LTPrint(plist);
LTNode* pos = LTFind(plist, 1);
if (pos)
{
LTErase(pos);
}
LTPrint(plist);
//主动置空
LTDestroy(plist);
plist = NULL;
}
void LTtest4()
{
LTNode* plist = LTInit();
LTPushBack(plist, 1);
LTPushBack(plist, 2);
LTPushBack(plist, 3);
LTPushBack(plist, 4);
LTPushBack(plist, 5);
LTPrint(plist);
int r = LTEmpty(plist);
printf("%d\n", r);
int size = LTSize(plist);
printf("%d\n", size);
//主动置空
LTDestroy(plist);
plist = NULL;
}
int main()
{
LTtest1();
return 0;
}
链表和顺序表对比
73
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
