用C语言实现双向链表

晨星05272024-08-11 18:33

目录

一.双向链表的结构

[二. 双向链表的实现](#二. 双向链表的实现)

[1. 在List.h中结构体的定义和各函数的声明](#1. 在List.h中结构体的定义和各函数的声明)

[1.1 结构体（节点）的定义](#1.1 结构体（节点）的定义)

[1.2 各函数的声明](#1.2 各函数的声明)

[2. 在List.c中各函数的实现](#2. 在List.c中各函数的实现)

[2.1 初始化 LTInit](#2.1 初始化 LTInit)

[2.2 尾插 LTPushBack](#2.2 尾插 LTPushBack)

[2.3 打印 LTPrint](#2.3 打印 LTPrint)

[2.4 头插 LTPushFront](#2.4 头插 LTPushFront)

[2.5 尾删 LTPopBack](#2.5 尾删 LTPopBack)

[2.6 头删 LTPopFront](#2.6 头删 LTPopFront)

[2.7 在指定位置后插入数据 LTInsert](#2.7 在指定位置后插入数据 LTInsert)

[2.8 查找 LTFind](#2.8 查找 LTFind)

[2.9 删除指定位置节点 LTErase](#2.9 删除指定位置节点 LTErase)

[2.10 销毁 LTDestroy](#2.10 销毁 LTDestroy)

[三. 顺序表和双向链表的优缺点分析](#三. 顺序表和双向链表的优缺点分析)

[四. 参考代码](#四. 参考代码)

[1. List.h](#1. List.h)

[2. List.c](#2. List.c)

[3. test.c](#3. test.c)

一.双向链表的结构

注意：这里的"带头"跟前面我们说的"头节点"是两个概念，实际前面的在单链表阶段称呼不严谨，但是为了更好的理解就直接称为单链表的头节点。

带头链表里的头节点，实际为"哨兵位"，哨兵位节点不存储任何有效元素，只是站在这里"放哨的"

"哨兵位"存在的意义：

遍历循环链表避免死循环。

二. 双向链表的实现

注：本次我们将实现一个双向带头循环链表。

1. 在List.h中结构体的定义和各函数的声明

1.1 结构体（节点）的定义

cpp 复制代码 
//重命名数据类型
typedef int LTDataType;

typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;//指向前一个节点
	struct ListNode* next;//指向后一个节点
}LTNode;

1.2 各函数的声明

cpp 复制代码 
//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit(void);

//尾插 -- 不改变哨兵位 -- 传一级指针
void LTPushBack(LTNode* phead, LTDataType x);

//打印
void LTPrint(LTNode* phead);

//头插
void LTPushFront(LTNode* phead, LTDataType x);

//尾删
void LTPopBack(LTNode* phead);

//头删
void LTPopFront(LTNode* phead);

//在指定位置后插入数据
void LTInsert(LTNode* pos, LTDataType x);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//删除指定位置节点
void LTErase(LTNode* pos);

//销毁
void LTDestroy(LTNode* phead);

2. 在List.c中各函数的实现

2.1 初始化 LTInit

既然涉及到插入新节点，那我们就需要创建一个新节点，由于每次插入都需要创建新节点，所以我们设计一个新函数专门来创建新节点。

cpp 复制代码 
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc failed");
		exit(1);
	}
	node->data = x;
	node->prev = node->next = node;

	return node;
}

注意：

  1. 每次malloc申请空间后应当检查是否申请成功。

  2. 将新申请的节点的前后指针指向自己，实现循环。

初始化操作我们需要创建哨兵节点 ，哨兵节点所带的值可以任意。

cpp 复制代码 
LTNode* LTInit(void)
{
	LTNode* node = LTBuyNode(EOF);
	return node;
}

2.2 尾插 LTPushBack

要对链表进行尾插，找到链表的哨兵节点 ，然后新节点插入哨兵节点的前一位 ，由于链表循环 ，所以也相当于尾插在链表尾。

cpp 复制代码 
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead ..... phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}

2.3 打印 LTPrint

我们创建一个指针pcur指向哨兵节点的下一个节点并沿着链表向后依次打印 ，如果等于哨兵节点 ，就说明已经遍历完成。

cpp 复制代码 
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

2.4 头插 LTPushFront

与尾插类似，在哨兵节点的下一位进行插入，注意连接好前后指针。

cpp 复制代码 
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead newnode phead->next ......
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}

2.5 尾删 LTPopBack

尾删前要注意链表有效且不为空 ，然后断开 要释放节点和前后节点的前后指针 ，最后释放该节点。

cpp 复制代码 
void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);//链表有效且不为空（只有一个哨兵位）

	//phead  ......  del->prev(phead->prev->prev)  del(phead->prev)
	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;

	//删除del节点
	free(del);
	del = NULL;
}

2.6 头删 LTPopFront

与头删类似，在哨兵节点的下一位进行删除，注意连接好前后指针。

cpp 复制代码 
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);

	LTNode* del = phead->next;

	//phead  del(phead->next)  del->next(phead->next->next) ......
	phead->next = del->next;
	del->next->prev = phead;

	//删除del节点
	free(del);
	del = NULL;
}

2.7 在指定位置后插入数据 LTInsert

函数参数中提供了插入位置 pos，连接好前后指针即可。

cpp 复制代码 
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);

	//... pos newnode pos->next ...
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
}

2.8 查找 LTFind

与打印类似，遍历一次 链表，查找 是否有符合条件的节点，如果有返回节点指针 ，如果没有 ，返回空指针。

cpp 复制代码 
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

2.9 删除指定位置节点 LTErase

与在打印和查找类似，函数参数中提供了删除位置 pos，处理好前后指针即可。

cpp 复制代码 
void LTErase(LTNode* pos)
{
	//pos理论上不能为phead，但是参数有限，无法校验
	assert(pos);

	//... pos->prev pos pos->next ...
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

2.10 销毁 LTDestroy

与在指定位置后插入数据类似，从哨兵节点的下一位遍历一次 链表，遍历的同时用双指针法依次释放节点 ，最后释放哨兵节点。

cpp 复制代码 
void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* pcur = phead->next;
	while(pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}

	//销毁phead
	free(phead);
	phead = NULL;
	pcur = NULL;
}

我们可以发现，由于双向链表具有指向前后节点的指针，代码量大大减少，但是也需要处理好指针之间的关系。

三. 顺序表和双向链表的优缺点分析

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

应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁
[顺序表和双向链表的优缺点]

四. 参考代码

1. List.h

cpp 复制代码 
#pragma once

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

//重命名数据类型
typedef int LTDataType;

typedef struct ListNode
{
	LTDataType data;
	struct ListNode* prev;//指向前一个节点
	struct ListNode* next;//指向后一个节点
}LTNode;

//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit(void);

//尾插 -- 不改变哨兵位 -- 传一级指针
void LTPushBack(LTNode* phead, LTDataType x);

//打印
void LTPrint(LTNode* phead);

//头插
void LTPushFront(LTNode* phead, LTDataType x);

//尾删
void LTPopBack(LTNode* phead);

//头删
void LTPopFront(LTNode* phead);

//在指定位置后插入数据
void LTInsert(LTNode* pos, LTDataType x);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//删除指定位置节点
void LTErase(LTNode* pos);

//销毁
void LTDestroy(LTNode* phead);

2. List.c

cpp 复制代码 
#include "List.h"

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc failed");
		exit(1);
	}
	node->data = x;
	node->prev = node->next = node;

	return node;
}

//void LTInit(LTNode** pphead)
//{
//	//给双向链表创建一个哨兵位
//	*pphead = LTBuyNode(-1);
//}
LTNode* LTInit(void)
{
	LTNode* node = LTBuyNode(EOF);
	return node;
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead ..... phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}

void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead newnode phead->next ......
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}

void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);//链表有效且不为空（只有一个哨兵位）

	//phead  ......  del->prev(phead->prev->prev)  del(phead->prev)
	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;

	//删除del节点
	free(del);
	del = NULL;
}

void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);

	LTNode* del = phead->next;

	//phead  del(phead->next)  del->next(phead->next->next) ......
	phead->next = del->next;
	del->next->prev = phead;

	//删除del节点
	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;
}

void LTErase(LTNode* pos)
{
	//pos理论上不能为phead，但是参数有限，无法校验
	assert(pos);

	//... pos->prev pos pos->next ...
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

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

	//销毁phead
	free(phead);
	phead = NULL;
	pcur = NULL;
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);

	//... pos newnode pos->next ...
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
}

3. test.c

cpp 复制代码 
#include "List.h"

void ListTest01()
{
	LTNode* plist = NULL;
	plist = LTInit();

	//LTPushBack(plist, 1);
	//LTPushBack(plist, 2);
	//LTPushBack(plist, 3);
	//LTPushBack(plist, 4);
	//LTPushBack(plist, 5);
	//LTPrint(plist);

	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);
	LTPushFront(plist, 5);
	LTPrint(plist);

	//LTPopBack(plist);
	//LTPrint(plist);
	//LTPopBack(plist);
	//LTPrint(plist);
	//LTPopBack(plist);
	//LTPrint(plist);

	//LTPopFront(plist);
	//LTPrint(plist);
	//LTPopFront(plist);
	//LTPrint(plist);
	//LTPopFront(plist);
	//LTPrint(plist);

	//LTNode* find = NULL;
	//find = LTFind(plist, 2);
	//if (find)
	//{
	//	printf("找到了！\n");
	//}
	//else
	//{
	//	printf("找不到！\n");
	//}
	//find = LTFind(plist, 7);
	//if (find)
	//{
	//	printf("找到了！\n");
	//}
	//else
	//{
	//	printf("找不到！\n");
	//}

	//LTNode* find = NULL;
	//find = LTFind(plist, 2);
	//if (find)
	//{
	//	printf("找到了！\n");
	//}
	//else
	//{
	//	printf("找不到！\n");
	//}
	//LTInsert(find, 6);
	//LTPrint(plist);
	//LTErase(find);
	//find = NULL;
	//LTPrint(plist);

	LTDestroy(plist);
	plist = NULL;
}

int main()
{
	ListTest01();
	return 0;
}
相关推荐
冠位观测者1 小时前
【Leetcode 热题 100】208. 实现 Trie (前缀树)
数据结构·算法·leetcode
西猫雷婶1 小时前
python学opencv|读取图像（十九）使用cv2.rectangle()绘制矩形
开发语言·python·opencv
liuxin334455662 小时前
学籍管理系统：实现教育管理现代化
java·开发语言·前端·数据库·安全
码农W2 小时前
QT--静态插件、动态插件
开发语言·qt
ke_wu2 小时前
结构型设计模式
开发语言·设计模式·组合模式·简单工厂模式·工厂方法模式·抽象工厂模式·装饰器模式
code04号2 小时前
python脚本：批量提取excel数据
开发语言·python·excel
小王爱吃月亮糖2 小时前
C++的23种设计模式
开发语言·c++·qt·算法·设计模式·ecmascript
hakesashou3 小时前
python如何打乱list
开发语言·python
网络风云3 小时前
【魅力golang】之-反射
开发语言·后端·golang
Want5954 小时前
Java圣诞树
开发语言·python·信息可视化
热门推荐
01【数学建模】建筑工地开工问题02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04液体神经网络：LNN是个啥概念？05优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间06HCIA-datacom数通题库和录播视频资料07Qt | 开发工具(top1)08【一文读懂】NTN（非地面网络）技术介绍09支付宝短视频平台创作分成激励项目10Apache SeaTunnel 集群部署详细教程