数据结构004 - 线性表（双向带头循环链表）

已于 2022-04-23 16:04:16 修改
阅读量1.2k 收藏
点赞数
分类专栏： 数据结构初阶（C语言实现） 文章标签： 数据结构 算法 c语言
于 2022-04-22 09:51:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44944301/article/details/124337893
版权

1. 链表的分类

链表可分为八类。

单向链表双向链表
单向带头循环双向带头循环
单向带头不循环双向带头不循环
单向不带头循环双向不带头循环
单向不带头不循环双向不带头不循环

上一篇 单链表 的博文中，主要实现的是 单向不带头非循环链表 的链表结构。这种链表结构，结构简单，一般不会单独用来存储数据。实际中更多地是作为其他数据结构的子结构，如哈希桶、图的邻接表等。

本文主要实现 双向带头循环链表 的链表结构。这种链表结构，结构最复杂，一般用于单独存储数据。实际中使用的链表数据结构，都是双向带头循环链表。 另外，这种结构虽然结构复杂，但是代码实现以后会发现结构会带来很多优势，实现反而简单了。

2.什么是双向带头循环链表

双向带头循环链表是由一个数据域和两个指针域组成，其中指针包含前驱指针 prev 和后继指针 next。其中 prev 指向上一个节点，next 指向下一个节点。

双向带头循环链表

3. 双向带头循环链表的实现

代码的实现将放在三个文件中，分别是 List.h（用于声明）、List.c（用于定义）、Test.c（用于测试）。

List.h 文件

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <assert.h>

typedef int LTDataType;

// 双向带头循环链表的结构
typedef struct ListNode{
	LTDataType data;       // 数据域，存储数据
	struct ListNode* next; // 后继指针，存储下一个节点的地址
	struct ListNode* prev; // 前驱指针，存储上一个节点的地址
}ListNode;

// 双向带头循环链表的初始化
ListNode* ListInit();

// 创建一个新节点
ListNode* BuyListNode(LTDataType x);

// 打印
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 ListDestroy(ListNode* phead);

3.1 创建一个新节点

List.c 文件

#include "List.h"

// 创建一个新节点
ListNode* BuyListNode(LTDataType x){
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	// 检查内存是否开辟成功
	if (newnode == NULL){
		printf("malloc fail\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

3.2 双向带头循环链表的初始化

思路： 创建的链表为带头链表，所以在初始化链表时，需要将作为哨兵位的头节点创建好。作为哨兵位的头节点不存储数据，但却有着至关重要的作用。当链表为空链表时，头节点仍然存在。同时因为是双向链表，所以头节点的 prev 和 next 都指向自己。

List.c 文件

#include "List.h"

// 双向带头循环链表的初始化
ListNode* ListInit(){
	// 创建作为哨兵位的头节点，不存储有效数据
	ListNode* phead = BuyListNode(0);
	phead->next = phead; // 后继指针指向自己
	phead->prev = phead; // 前驱指针指向自己

	return phead;
}

3.3 打印

思路： 首先需要明确的是，作为哨兵位的头节点不存储数据，所以需要创建一个指针变量 cur 从 phead->next 开始依次遍历打印链表。因为链表是循环的，所以当 cur 回到 phead 时停止。

List.c 文件

#include "List.h"

// 打印
void ListPrint(ListNode* phead){
	assert(phead);

	ListNode* cur = phead->next;
	while (cur != phead){
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

3.4 尾插

思路： 尾插体现了双向循环链表的结构优势，因为头节点的 phead->prev 指向了链表尾节点的地址，所以就找到了尾节点，此时需要再创建一个节点存储插入的数据。最后将头节点 phead、原尾节点 tail、新节点 newnode 链接起来即可。

思路

List.c 文件

#include "List.h"

// 尾插
void ListPushBack(ListNode* phead, LTDataType x){
	assert(phead);
	
	ListNode* tail = phead->prev; // 保存尾节点地址
	ListNode* newnode = BuyListNode(x); // 创建一个新的节点
	newnode->data = x;

	// 将头节点 phead、原尾节点 tail、新节点 newnode 链接起来
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

	// 方法二、调用 ListInsert 函数
	// ListInsert(phead, x);
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	// 打印
	ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.5 尾删

思路： 尾删同样体现了双向循环链表的结构优势。因为链表是循环的，所以链表尾节点的地址保存在头节点的 prev 中。我们可以创建指针变量 tail 保存尾节点地址。在删除尾节点时，也要保证尾节点的上一个节点的地址被保存，所以创建指针变量 tailPrev 指向 tail->prev，然后把 tailPrev 的 next 指向头节点 phead，将 phead 的 prev 置成 tailPrev。

思路

List.c 文件

#include "List.h"

// 尾删
void ListPopBack(ListNode* phead){
	assert(phead); // 哨兵位不能为空
	assert(phead->next != phead); // 链表不能为空，防止删除作为哨兵位的头节点

	ListNode* tail = phead->prev; // 尾节点地址放入 tail
	ListNode* tailPrev = tail->prev; // 新的尾节点 tailPrev

	free(tail);
	tail = NULL;
	// 将头节点 phead、原尾节点的上一个节点 tailPrev 链接起来
	tailPrev->next = phead;
	phead->prev = tailPrev;

	// 方法二、调用 ListErase 函数
	//ListErase(phead->prev);
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 6; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	// 尾删
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	// 打印
	ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.6 头插

思路： 首先创建一个新节点 newnode，创建指针变量 next 保存 phead->next（即头节点的下一个节点的地址）。然后将头节点 phead、新节点 newnode、原头节点的下一个节点链接起来。

思路

List.c 文件

#include "List.h"

// 头插
void ListPushFront(ListNode* phead, LTDataType x){
	assert(phead);
	
	ListNode* newnode = BuyListNode(x);
	ListNode* next = phead->next; // 先找到头
	
	// 将头节点 phead、新节点 newnode、原头节点的下一个节点链接起来
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
	
	// 方法二、调用 ListInsert 函数
	//ListInsert(phead->next, x);
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	// 头插
	ListPushFront(plist, 10);
	ListPushFront(plist, 20);
	// 打印
    ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.7 头删

思路： 创建指针变量 next 保存 phead->next（即哨兵位的下一个节点的地址），再创建指针变量 nextNext 保存 next->next（即哨兵位后的第二个节点的地址）。然后将哨兵位 phead、哨兵位后的第二个节点链接起来。

思路

List.c 文件

#include "List.h"

// 头删
void ListPopFront(ListNode* phead){
	assert(phead);
	// 如果哨兵位的后继指针指向头，即链表为空，则不能进行头删
	assert(phead->next != phead);
	
	ListNode* next = phead->next; // 先找到哨兵位的下一个节点
	ListNode* nextNext = next->next; // 再找到哨兵位后的第二个节点
	
	// 将哨兵位 phead、哨兵位后的第二个节点链接起来，并释放原哨兵位的下一个节点
	phead->next = nextNext;
	nextNext->prev = phead;
	free(next);

	// 方法二、调用 ListErase 函数
	//ListErase(phead->next);
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	
	// 头删
	ListPopFront(plist);
	ListPopFront(plist);
	// 打印
	ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.8 查找

思路： 创建一个指针变量 cur 指向哨兵位 phead 的 next，然后遍历链表。判断 cur->data 是否为查找的数据，如果是则返回 cur，不是则继续遍历，终止条件是 cur 指向哨兵位节点（即遍历完成，找不到所查找的数据）。

List.c 文件

#include "List.h"

// 查找
ListNode* ListFind(ListNode* phead, LTDataType x){
	assert(phead);

	ListNode* cur = phead->next;
	while (cur != phead){
		// 找到返回对应的地址
		if (cur->data == x){
			return cur;
		}
		// 找不到继续向后找
		cur = cur->next;
	}
	// 彻底找不到
	return NULL;
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	
	// 查找
	ListNode* pos = ListFind(plist, 2);
	if (pos){
		printf("找到了，pos 节点：%p->%d\n", pos, pos->data);
	}
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.9 在 pos 位置之前插入数据

思路： 创建一个新节点 newnode，创建一个指针变量 posPrev 保存 pos->prev（即储存 pos 位置的上一个节点的地址），将 posPrev->next 指向新节点 newnode，同时将 newnode->prev 指向 posPrev，newnode->next 指向 pos，pos->prev 指向 newnode。

思路

List.c 文件

#include "List.h"

// 在 pos 位置之前插入数据
void ListInsert(ListNode* pos, LTDataType x){
	assert(pos);
	
	// 创建插入节点
	ListNode* newnode = BuyListNode(x);
	// 储存 pos 位置的上一个节点地址
	ListNode* posPrev = pos->prev;

	// 将 pos 的上一个节点 posPrev、新节点 newnode、pos 节点链接起来
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	
	// 查找
	ListNode* pos = ListFind(plist, 2);
	if (pos){
		// 在 pos 位置之前插入数据
		ListInsert(pos, 10);
	}
	// 打印
	ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.10 删除 pos 位置的节点

思路： 创建两个指针变量 posPrev 和 posNext 分别保存 pos 位置的上一个节点和下一个节点的地址，然后将 pos 节点 free 掉，连接 posPrev 和 posNext。

思路

List.c 文件

#include "List.h"

// 删除 pos 位置的节点
void ListErase(ListNode* pos){
	assert(pos);
	
	// 保存 pos 位置的前一个节点
	ListNode* posPrev = pos->prev;
	// 保存 pos 位置的下一个节点
	ListNode* posNext = pos->next;
	
	// 将 pos 的上一个节点 posPrev、下一个节点 posNext链接起来
	posPrev->next = posNext;
	posNext->prev = posPrev;
	
	free(pos);
	pos = NULL;
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	
	// 查找
	ListNode* pos = ListFind(plist, 2);
	if (pos){
		// 删除 pos 位置的节点
        ListErase(pos);
	}
	// 打印
	ListPrint(plist);
}


int main(){
	TestList1();

	return 0;
}

运行结果：

运行结果

3.11 销毁

思路： 创建指针变量 cur 遍历链表，先将有效数据的节点 free 掉，最后再将哨兵位节点 free 掉即可。

List.c 文件

#include "List.h"

// 销毁
void ListDestroy(ListNode* phead){
	assert(phead);

	// 在销毁链表时，需要将节点逐个销毁，
	// 销毁前一个节点，必须要保存下一个节点的地址
	ListNode* cur = phead->next;
	while (cur != phead){
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	
	free(phead);
	phead = NULL;
}

Test.c 文件

#include "List.h"

void TestList1(){
	// 初始化链表
	ListNode* plist = ListInit();
	// 尾插
	for (int i = 0; i < 4; i++){
		ListPushBack(plist, i);
	}
	// 打印
	ListPrint(plist);
	
    // 销毁
	ListDestroy(plist);
}


int main(){
	TestList1();

	return 0;
}

4. 顺序表与链表的对比总结

不同点顺序表链表
存储空间物理上连续逻辑上连续
随机访问支持 O(1) 的随机访问不支持随机访问，访问元素需要 O(N)
任意位置插入删除需要移动元素，O(N)只需改变指针指向
插入数据要考虑扩容，会带来一定的空间消耗没有容量的概念，可以按需申请和释放
缓存利用率高低
应用场景元素高效存储以及频繁访问的场景任意位置插入和删除频繁的场景
疯狂的豆子2019
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
双向带头循环链表
线性表——双向循环链表的C语言实现
qq_41536160的博客
12-17 608
在双向链表的结点中有两个指针域，一个指向直接后继， 另一个指向直接前驱。 双向循环链表的C语言实现 头文件 #include<stdio.h> #include<stdlib.h> //结果函数状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define MAXSIZE 100 //顺序表可能达到的最大长度
《数据结构》（四）线性表之双向带头循环链表的实现及详解
Miraitowa_GT的博客
08-05 615
C语言九千字解析，带你深刻理解链表
C++实现线性表 - 03 双向循环链表
Newin2020的博客
02-28 1156
数据结构与算法C++代码实现之线性表双向循环链表部分
数据结构c版（1）-线性表文章代码汇总
11-19
顺序表，单链表，双向带头循环链表，栈，队列代码
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **链表分类**：在实际应用中，最常见的链表类型是无头单向非循环链表（常作为其他数据结构的子结构）和带头双向循环链表（用于独立存储数据）。 - **链表的实现**：链表节点通常包含数据和指向下一个节点的指针...
漫话数据结构-单循环链表及基本操作.pptx
11-03
在这个主题中，我们将专注于单循环链表，一种结合了链式存储和循环特性的数据结构。单循环链表是线性表的链式存储实现，它提供了一种灵活的方法来处理数据的插入、删除和访问操作。 首先，让我们理解单循环链表的...
02-第2章线性表第7讲-双向链表和双向循环链表.pdf
12-16
本章所指的双向链表均指带头结点的双向循环链表。 5. 双向循环链表上的算法实现 在带头结点的双向循环链表中，通常头结点的数据域可以不存储任何信息。双向循环链表上的算法实现可以分为三部分：链表长度算法、...
【CPP】插入排序、希尔排序
2302_79031646的博客
06-18 232
插入排序、希尔排序
九、数据结构（并查集）
n666fgh的博客
06-13 805
通常用“帮派”的例子来说明并查集的应用背景：在一个城市中有nn1061号、2号是朋友；1号、3号也是朋友，那么他们都属于一个帮派。在分析完所有的朋友关系之后，问有多少帮派，每人属于哪个帮派。这个数据量应该是不能用暴力的办法求解，那我们应该怎么办呢？由此，我们引出一种新的数据结构：并查集。
十、数据结构（图的基础）
n666fgh的博客
06-15 538
intgraphNNintgraphNN，每个节点graphijgraphij表示从iii到jjj的距离。graphii!
数据结构之LinkedList与链表（上）
我要学编程的博客
06-12 1195
手动实现单链表的源码 手动实现双链表的源码 分析LinkedList 的源码 LinkedList的使用：常用方法 ArrayList 和 LinkedList的区别
代码随想录第20天|二叉树
qq_45699949的博客
06-11 194
你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null。虽然开辟额外空间, 但结果依旧受到原来的数影响(当为null时直接借用了原来数的节点)构造二叉树: 使用前序遍历。需要利用二叉搜索树的性质。
从零开始学数据结构系列之第三章《后续线索二叉树线索化理论》
最新发布
铁匠匠匠的博客
06-19 642
仔细想想，我们中序遍历这个是 左 右 中，而我们这个先序遍历是直接寻找最左边的节点，所以我们以防万一下图这种情况。我们继续还是用这个图，我们根据前面学习的中序线索二叉树和先序线索二叉树，来看看着后续线索二叉树怎么写。如果是这种情况，我们想上述的代码是不能有效的完成工作的，所以我们需要一些简单的修改。答案是没有的，可以直接正常运行的，那我们接下来看看下面的是否可以直接用。​ 我们再看到中序线索二叉树是怎么写的，看看稍微修改下直接用行不行。就例如创树和结构初始化都是一样的。​ 这是我们中序线索二叉树写的。
数据结构——二叉树
Yuan_o_的博客
06-18 571
树是一种非线性的数据结构，由n（n>=0）个有限节点组成一个具有层次关系的集合特点：有一个特殊的节点，称为根节点，根节点没有前驱节点树是递归定义的树形结构中，子树之间不能有交集，否则就不是树形结构除了根节点外，每个节点有且仅有一个父节点一棵个节点的树有条边。
408数据结构-图的遍历 自学知识点整理
Engels_Si_Fish的博客
06-15 1041
25考研知识点个人向总结。
【408考点之数据结构】数据结构的基本概念
gygkhd的博客
06-18 441
存储结构则是数据在计算机内存中的存储形式，主要有顺序存储和链式存储两种。顺序存储将数据元素存放在连续的存储单元中，而链式存储则将数据元素存放在不连续的存储单元中，通过指针来表示数据元素之间的关系。数据结构是计算机科学中一个非常重要的概念，它描述了数据元素之间的关系及其在计算机内存中的组织方式。例如，在需要快速访问数据的场景中，顺序存储的数组是一个很好的选择；而在需要频繁插入和删除数据的场景中，链式存储的链表则更为合适。数据结构的核心在于它的三要素：逻辑结构、存储结构和数据运算。
Java 数据结构：栈和队列
2301_78864183的博客
06-15 540
栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。想象一个叠放的盘子堆，你只能从顶部添加或移除盘子。栈的操作也类似，元素从栈顶添加（压栈）和移除（弹栈）。队列是一种遵循先进先出（FIFO, First In First Out）原则的数据结构。队列就像排队买票，先到的人先买票。队列的操作分别在两端进行：一端用于添加元素（入队），另一端用于移除元素（出队）。在Java中，我们可以利用Stack类、Queue接口及其各种实现类（如LinkedListArrayDeque。
【数据结构】二叉树：一场关于节点与遍历的艺术之旅
萌新的博客
06-12 1741
前面我们说过顺序存储结构一般只适用于完全二叉树，既然顺序存储适应性不强，我们既要考虑链式存储结构了。二叉树每个节点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表为二叉链表。
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值