双向链表的实现

于 2024-08-02 17:37:54 发布
阅读量552 收藏 8
点赞数 17
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80934913/article/details/140871706
版权

双向链表

1. 双向链表

在这里插入图片描述

  • 一个典型的双向链表节点包含三个部分：

    • 数据域（data），用于存储节点的实际数据。
    • 指向前一个节点的指针（prev）。
    • 指向下一个节点的指针（next）。

2. 双向链表的基本操作

  1. 初始化
  2. 打印
  3. 头插
  4. 尾插
  5. 头删
  6. 尾删
  7. 查找
  8. 在指定位置pos之后插入
  9. 删除指定位置pos
    10.销毁链表

3. 实现双线链表的准备

  • 定义List.h,List.c,Test.c三个文件，头文件包含双向链表相关的数据结构的定义和函数声明，实现文件包含双向链表功能的具体实现细节，测试文件用于测试双向链表的功能。

4. 代码的实现

4.1 在头文件中进行函数声明

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

//创建双向链表
typedef int LTDataType;
typedef struct LTNode {
	LTDataType data;
	struct LTNode* next;
	struct LTNode* prev;
}LTNode;

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

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

//尾插
void LTPushBack(LTNode* phead, LTDataType x);

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

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

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

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

//在指定位置之后插入
LTNode* LTInsertBack(LTNode* phead, LTDataType x,LTNode* pos);

//删除结点pos
void LTDel(LTNode* pos);

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

4.2 链表的初始化

  • 创建一个哨兵位，不储存有效数据
//初始化
void LTInit(LTNode** phead) 
{
	//创建一个哨兵位
	*phead = buyNode(-1);
}

4.3 链表的销毁

  1. 断言检查：
    assert(phead); 这一行用于确保传入的头节点 phead 不是 NULL。防止尝试释放一个不存在的链表。
  2. 初始化遍历指针：
    LTNode* pcur = phead->next; 初始化一个指针 pcur 为头节点 phead 的下一个节点。
  3. 遍历并释放节点：
    • while (pcur != phead) { ... } 开始一个循环，条件是在 pcur 指向的节点不是头节点 phead 时继续执行。
    • LTNode* next = pcur->next; 在释放当前节点之前，保存下一个节点的地址到 next 中。
    • free(pcur); 释放当前节点 pcur 占用的内存。
    • pcur = next; 将 pcur 更新为下一个节点。
  4. 释放头节点：
    • free(phead); 当循环结束时，说明所有中间节点已经被释放，此时释放头节点 phead。
    • 设置头节点为 NULL：
    • phead = NULL; 将头节点指针设置为 NULL。
//销毁
void LTDestroy(LTNode* phead) {
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead) {
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}

4.4 链表的打印

  1. 断言检查；
  2. 处理空链表：
    • if (phead->next == phead) { printf("NULL"); } 这一行检查如果链表为空（即只有一个头节点，且 phead->next 指向自己），则输出 “NULL”。
  3. 初始化遍历指针：
    • LTNode* pcur = phead->next; 初始化一个指针 pcur 为头节点 phead 的下一个节点。这是遍历链表的起点。
  4. 遍历并打印数据：
    • while (pcur != phead) { ... } 开始一个循环，条件是在 pcur 指向的节点不是头节点 phead 时继续执行。
    • printf("%d->", pcur->data); 打印当前节点的数据，后面跟着一个箭头。
    • pcur = pcur->next; 将 pcur 更新为下一个节点。
  5. 结束打印：
    • printf("\n"); 在循环结束后打印换行符，以确保输出格式清晰。
//打印
void LTPrint(LTNode* phead) {
	assert(phead && phead->next != phead);
	if (phead->next == phead) {
		printf("NULL");
	}
	LTNode* pcur = phead->next;
	while (pcur != phead) {
		printf("%d->",pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

4.5 链表的头插

  1. 断言检查
  2. 创建新节点：
    LTNode* newnode = buyNode(x); 创建一个新节点，其中 x 是要插入的数据。
  3. 更新新节点的指针：
    newnode->next = phead->next; 设置新节点的 next 指针指向原来的头节点的下一个节点。
    newnode->prev = phead; 新节点的 prev 指针指向头节点 phead。
  4. 更新原头节点下一个节点的指针：
    phead->next->prev = newnode; 原头节点下一个节点的 prev 指针指向新节点。
  5. 更新头节点的指针：
    phead->next = newnode; 头节点的 next 指针指向新节点。
//头插
void LTPushFront(LTNode* phead, LTDataType x) {
	assert(phead);

	LTNode* newnode = buyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;

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

4.6 链表的头删

  1. 断言检查
  2. 选择要删除的节点：
    LTNode* del = phead->next; 获取要删除的节点，即头节点 phead 的下一个节点。
  3. 更新头节点的指针：
    phead->next = del->next; 将头节点的 next 指针更新为原来被删除节点的下一个节点。
  4. 更新被删除节点的下一个节点的指针：
    del->next->prev = phead; 将原来被删除节点的下一个节点的 prev 指针更新为头节点 phead。
  5. 释放被删除的节点：
    free(del); 释放被删除节点 del 占用的内存。
  6. 设置被删除节点指针为 NULL：
    del = NULL; 将 del 指针设置为 NULL。
//头删
void LTPopFront(LTNode* phead) {
	assert(phead && phead->next != phead);

	LTNode* del = phead->next;

	phead->next = del->next;
	del->next->prev = phead;

	free(del);
	del = NULL;
}

4.7 链表的尾插

  1. 断言检查
  2. 创建新节点：
    LTNode* newnode = buyNode(x); 创建一个新节点，其中 x 是要插入的数据。这里假设 buyNode 函数已经被定义好，用于分配新节点所需的内存，并初始化节点的数据成员。
  3. 更新新节点的指针：
    newnode->prev = phead->prev; 新节点的 prev 指针指向原来的尾节点。
    newnode->next = phead; 新节点的 next 指针指向头节点 phead。
  4. 更新原尾节点的 next 指针：
    phead->prev->next = newnode; 原尾节点的 next 指针指向新节点。
  5. 更新头节点的 prev 指针：
    phead->prev = newnode; 头节点的 prev 指针指向新节点。
//尾插
void LTPushBack(LTNode* phead, LTDataType x) 
{
	assert(phead);
	LTNode* newnode = buyNode(x);

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

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

4.8 链表的尾删

  1. 断言检查
  2. 选择要删除的节点：
    LTNode* del = phead->prev; 获取要删除的节点，即头节点 phead 的前一个节点，也就是链表的尾部节点。
  3. 更新头节点的指针：
    phead->prev = del->prev; 将头节点的 prev 指针更新为原来被删除节点的前一个节点。
  4. 更新被删除节点的前一个节点的指针：
    del->prev->next = phead; 将原来被删除节点的前一个节点的 next 指针更新为头节点 phead。
  5. 释放被删除的节点：
    free(del); 释放被删除节点 del 占用的内存。
  6. 设置被删除节点指针为 NULL：
    del = NULL; 将 del 指针设置为 NULL。
//尾删
void LTPopBack(LTNode* phead) {
	assert(phead && phead->next != phead);//确保链表不为空

	LTNode* del = phead->prev;

	phead->prev = del->prev;
	del->prev->next = phead;

	free(del);
	del = NULL;
}

4.9 查找

  1. 初始化遍历指针：
    LTNode* pcur = phead->next; 初始化一个指针 pcur 为头节点 phead 的下一个节点。这是遍历链表的起点。
  2. 遍历链表：
    while (pcur != phead) { ... } 开始一个循环，条件是在 pcur 指向的节点不是头节点 phead 时继续执行。
    if (pcur->data == x) { return pcur; } 如果当前节点的数据等于查找的数据 x，则返回当前节点。
    pcur = pcur->next; 将 pcur 更新为下一个节点。
  3. 未找到节点：
    如果循环结束还没有找到匹配的节点，则返回 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;
}

4.10 在指定位置之后插入

  1. 断言检查
  2. 创建新节点：
    LTNode* newnode = buyNode(x); 创建一个新节点，其中 x 是要插入的数据。这里假设 buyNode 函数已经被定义好，用于分配新节点所需的内存，并初始化节点的数据成员。
  3. 更新新节点的指针：
    newnode->next = pos->next; 新节点的 next 指针指向位置节点 pos 的下一个节点。
    newnode->prev = pos; 新节点的 prev 指针指向位置节点 pos。
  4. 更新位置节点的下一个节点的指针：
    pos->next->prev = newnode; 位置节点 pos 的下一个节点的 prev 指针指向新节点。
  5. 更新位置节点的指针：
    pos->next = newnode; 位置节点 pos 的 next 指针指向新节点。
//在指定位置之后插入
LTNode* LTInsertBack(LTNode* phead, LTDataType x,LTNode* pos) {
	assert(pos);
	LTNode* newnode = buyNode(x);

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

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

4.11 删除指定位置pos的值

  1. 断言检查：
  2. 更新节点的前后指针：
    pos->prev->next = pos->next; 节点 pos 的前一个节点的 next 指针指向节点 pos 的下一个节点。
    pos->next->prev = pos->prev; 节点 pos 的下一个节点的 prev 指针指向节点 pos 的前一个节点。
  3. 释放节点：
    free(pos); 释放节点 pos 占用的内存。
  4. 设置节点指针为 NULL：
    pos = NULL; 将 pos 指针置为 NULL。
//删除结点pos
void LTDel(LTNode* pos) {
	assert(pos);

	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;

	free(pos);
	pos = NULL;
}

5. 完整代码

List.h:

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

//创建双向链表
typedef int LTDataType;
typedef struct LTNode {
	LTDataType data;
	struct LTNode* next;
	struct LTNode* prev;
}LTNode;

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

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

//尾插
void LTPushBack(LTNode* phead, LTDataType x);

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

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

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

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

//在指定位置之后插入
LTNode* LTInsertBack(LTNode* phead, LTDataType x,LTNode* pos);

//删除结点pos
void LTDel(LTNode* pos);

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

List.c:

#include"List.h"

//创建节点
LTNode* buyNode(LTDataType x) {
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = newnode->prev = newnode;
	return newnode;
}

//打印
void LTPrint(LTNode* phead) {
	assert(phead && phead->next != phead);
	if (phead->next == phead) {
		printf("NULL");
	}
	LTNode* pcur = phead->next;
	while (pcur != phead) {
		printf("%d->",pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//初始化
void LTInit(LTNode** phead) 
{
	//创建一个哨兵位
	*phead = buyNode(-1);
}

//尾插
void LTPushBack(LTNode* phead, LTDataType x) 
{
	assert(phead);
	LTNode* newnode = buyNode(x);

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

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

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

	LTNode* newnode = buyNode(x);
	newnode->next = phead->next;
	newnode->prev = phead;

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

//尾删
void LTPopBack(LTNode* phead) {
	assert(phead && phead->next != phead);//确保链表不为空

	LTNode* del = phead->prev;

	phead->prev = del->prev;
	del->prev->next = phead;

	free(del);
	del = NULL;
}

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

	LTNode* del = phead->next;

	phead->next = del->next;
	del->next->prev = phead;

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

//在指定位置之后插入
LTNode* LTInsertBack(LTNode* phead, LTDataType x,LTNode* pos) {
	assert(pos);
	LTNode* newnode = buyNode(x);

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

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

//删除结点pos
void LTDel(LTNode* pos) {
	assert(pos);

	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;
	}
	free(phead);
	phead = NULL;
}

Test.c:

#include"List.h"
#include<stdio.h>

void Test() {
	LTNode* plist = NULL;

	LTInit(&plist);
	//测试尾插
	/*LTPushBack(plist, 1);
	LTPushBack(plist, 3);
	LTPushBack(plist, 1);
	LTPushBack(plist, 4);
	LTPrint(plist);*/

	//测试头插
	LTPushFront(plist, 0);
	LTPushFront(plist, 3);
	LTPushFront(plist, 5);
	LTPrint(plist);

	//测试尾删
	//LTPopBack(plist);
	//LTPrint(plist);

	//测试头删
	LTPopFront(plist);
	LTPrint(plist);

	//测试查找
	LTNode* find = LTFind(plist, 3);
	if (find != NULL) {
		printf("找到了！\n");
	}
	else {
		printf("没找到！\n");
	}

	//测试在指定位置之后插入
	LTInsertBack(plist, 8, find);
	LTPrint(plist);

	//测试删除结点pos
	LTDel(find);
	LTPrint(plist);

	//测试销毁
	LTDestroy(plist);
	plist = NULL;
}

int main() {
	Test();
	return 0;
}
干干干饭有点牛
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表实现
hxy1625309592的博客
12-15 2124
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
带头双向链表实现(带图详解)
fw5884179的博客
08-07 546
带头双向链表实现
双向链表实现栈
m0_56398287的博客
10-03 1282
双向链表来实现栈
【数据结构】双向链表实现
m0_73367097的博客
03-26 1653
双向链表的定义与实现
基于 HashMap 和 双向链表实现 LRU
ikun的博仔的博客
06-26 961
基于HashMap和双向链表实现LRU
基于双向链表实现的栈
Gee_Zer的博客
08-15 3630
看了LinkedList的源码，明白了LinkedList底层使用的是双向链表，一直想找个机会实现一下双向链表，今天写到力扣的每日一题20.有效的括号，正好此题需要使用到栈，所以借此机会来自己实现一下基于双向链表实现的栈，实现栈之前要了解以下知识 1.什么是双向链表 双向链表是指一个节点有一个数据域，两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，现在将指向上一个节点的指针域命名为pre，将指向下一个节点的指针域命名为next，节点命名为node，一个合格的双向链表如下图所示 中间的nod
用双向链表实现栈（C）
u014801954的博客
05-15 4572
目录 一.结构定义： 二.结构操作 三.测试代码 四.运用
使用线程安全型双向链表实现简单 LRU Cache 模拟
热门推荐
苏州程序大白的博客
11-16 1万+
使用线程安全型双向链表实现简单 LRU Cache 模拟目录????博主介绍前言1、动机1.1、要解决的问题2、系统设计2.1、系统总体框架2.2、系统功能模块2.3 系统整体流程3、数据结构设计4、关键技术与系统实现4.1、生成访问序列4.2 各进程的推进4.3、修改链表结构的相关方法实现4.4、访问链表的相关方法实现4.5、应用封装层的实现4.6、统计缓冲区命中率5、系统运行结果5.1、运行环境5.2、运行与测试结果5.2.1、运行结果5.2.2、链表方法测试6、调试与改进????作者相关的文章、资源分
java模拟双向链表实现
congge
03-10 6321
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 下图是双向链表的逻辑结构图，和单链表不同的是，双向链表中每个节点包含两个节点的指针引用，和一个数据域，这两个节点分别指向前一个节点和后一个节点； 双向链表的这种结构比起单链表，其改进之处正在于此，通过对前后节点的引用可以使得在...
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
2024.7.24 作业
qq_64434282的博客
07-24 2601
【代码】2024.7.24 作业。
C语言系统调用linux文件系统
C or CPP
07-25 1219
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
2024浙江省行政区划矢量图层-省市县乡镇四级行政区划数据下载-带python代码
最新发布
08-02
2024最新浙江省行政区划矢量图层数据，包含省、市、县、乡镇四级行政区划数据下载，附带shp转geojson的python代码
年度销售计划表.xlsx.xlsx
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
蓝牙BLE 4.0开发课程
08-01
蓝牙BLE 4.0课程
双向链表实现多级菜单
09-22
可以使用双向链表来实现多级菜单。在双向链表中，每个节点包含一个数据项和两个指针，一个指向前一个节点，一个指向后一个节点。通过这种方式，可以在多级菜单中轻松地实现上下级关系。 以下是一个使用双向链表实现多级菜单的示例代码： ```python class MenuItem: def __init__(self, label): self.label = label self.child = None self.parent = None self.next_sibling = None def create_menu(): # 创建根节点 root = MenuItem("Root") # 创建一级菜单项 level1_item1 = MenuItem("Level 1 Item 1") level1_item2 = MenuItem("Level 1 Item 2") # 将一级菜单项添加到根节点下 root.child = level1_item1 level1_item1.parent = root level1_item1.next_sibling = level1_item2 level1_item2.parent = root # 创建二级菜单项 level2_item1 = MenuItem("Level 2 Item 1") level2_item2 = MenuItem("Level 2 Item 2") # 将二级菜单项添加到一级菜单项下 level1_item1.child = level2_item1 level2_item1.parent = level1_item1 level2_item1.next_sibling = level2_item2 level2_item2.parent = level1_item1 # 创建更多菜单项... return root ``` 这样你就可以使用双向链表创建多级菜单。你可以根据需要添加更多菜单项，并设置它们之间的关系。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值