数据结构---双链表

最新推荐文章于 2024-04-20 21:28:50 发布
最新推荐文章于 2024-04-20 21:28:50 发布
阅读量541 收藏 3
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73888239/article/details/129460366
版权

专栏：数据结构
个人主页：HaiFan.
专栏简介：从零开始，数据结构！！

双链表

前言

在这里插入图片描述

双向链表是在结构体内存两个指针，一个指针存下一个结点的地址，另一个指针是存上一个结点的地址，这样，就可以通过一个结点，找到前后两个结点。听起来很复杂，但实现起来，要比单链表简单许多。

在这里插入图片描述

双链表：

typedef int LDataType;

typedef struct ListNode
{
	LDataType val;
	struct ListNode* head;
	struct ListNode* tail;
}LN;

双链表各接口的实现

LN* BuyLN(LDataType x);//为要插入的值开辟一块空间

void LNInit(LN** pphead);//初始化
void LNDestory(LN* phead);//销毁

void LNPrint(LN* phead);//打印链表中的值

void LNPushBack(LN* phead, LDataType x);//尾插
void LNPopBack(LN* phead);//尾删

void LNPushFront(LN* phead, LDataType x);//头插
void LNPopFront(LN* phead);//头删

bool LNEmpty(LN* phead);//双链表是否为空

LN* LNFind(LN* phead, LDataType x);//查找

void LNInsert(LN* pos, LDataType x);//任意位置插入
void LNErase(LN* pos);//任意位置删除

为要插入的值开辟一块空间BuyLN

这个BuyLN是为链表开辟一块空间，为什么要额外写一个这函数，因为在插入值的过程中，需要为这个值开辟一块空间，每次都需要写相同的代码，所以把这个代码写成一个函数，用到式直接调用函数即可

LN* BuyLN(LDataType x)
{
	LN* sn = (LN*)malloc(sizeof(LN));
	if (sn == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	sn->val = x;
	sn->head = NULL;
	sn->tail = NULL;

	return sn;
}

初始化LNInit和销毁LNDestory

双链表的初始化，只需要把链表中的head和tail指针都指向自己，形成一个环即可。

void LNInit(LN** pphead)
{
	(*pphead) = BuyLN(-1);
	(*pphead)->head = *pphead;
	(*pphead)->tail = *pphead;
}

在这里插入图片描述

空间有开辟就有销毁，销毁之后把空间还给系统

void LNDestory(LN* phead)//ٿռ
{
	assert(phead);

	LN* cur = phead->head;

	while (cur != phead)
	{
		LN* sn = cur;
		free(sn);
		sn = NULL;
		cur = cur->head;

	}
}

打印链表中的值LNPrint

头结点是不需要打印的，所以可以先定义一个sn代表头结点指向的下一个元素的位置，然后依次打印，直到sn的地址和头节点的地址相同时，打印结束

void LNPrint(LN* phead)
{
	assert(phead);
	LN* sn = phead->head;
	while (sn != phead)
	{
		cout << sn->val << ' ';
		sn = sn->head;
	}
	cout << endl;
}

尾插LNPushBack和尾删LNPopBack

单链表的尾插需要先遍历，找到尾，然后进行插入操作，双链表不同于单链表，双链表有两个指针，一个存下一个结点，一个存上一个结点，我们只需要在头节点的左面，也就是让头节点中存上一个结点存要插入的值即可，这样就能完成尾插。

在这里插入图片描述

这样就不需要在遍历链表，找尾了。

void LNPushBack(LN* phead, LDataType x)
{
	LN* newnode = BuyLN(x);
	LN* prev = phead->tail;

	prev->head = newnode;
	newnode->tail = prev;
	newnode->head = phead;
	phead->tail = newnode;
}

尾删依旧是把头节点左边的那一个元素给删除即可，当然，表中如果只有头节点，就不要在删除了。。。

void LNPopBack(LN* phead)
{
	assert(phead->head != phead->tail);
	LN* prev = phead->tail;

	prev->tail->head = phead;
	phead->tail = prev->tail;
	free(prev);
	prev = NULL;
}

头插LNPushFron和头删LNPopFront

在这里插入图片描述

头插的话，要先找到首元素，然后把要插入的元素和头节点，首元素都双向链接起来即可。

void LNPushFront(LN* phead, LDataType x)
{
	LN* newnode = BuyLN(x);
	LN* ne = phead->head;

	ne->tail = newnode;
	newnode->head = ne;
	phead->head = newnode;
	newnode->tail = phead;
}

头删的话呢，跟上面一样，要先找到首元素，然后让头节点和首元素指向的下一个元素链接起来即可。

void LNPopFront(LN* phead)
{
	assert(phead->head != phead->tail);

	LN* ne = phead->head;
	phead->head = ne->head;
	ne->head->tail = phead;
	free(ne);
	ne = NULL;

}

在这里插入图片描述

判断链表是否为空LNEmpty

如果链表为空返回true，反之，返回false，当双链表的头指针和尾指针都指向自己的时候，就说明，双链表为空。

bool LNEmpty(LN* phead)
{

	assert(phead);
	return phead->head == phead->tail;
}

查找LNFind

查找一个元素，返回这个元素的地址，只需要遍历双链表即可。

LN* LNFind(LN* phead, LDataType x)
{
	assert(phead);
	assert(phead->head != phead->tail);

	LN* cur = phead->head;

	while (cur != phead)
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->head;
	}
	return NULL;
}

任意位置插入 LNInsert

再插入之前，要先找到要插入的位置，寻找这个位置的任务就交给了上面写的查找函数，我们只需要传递参数，对该位置进行插入即可，

void LNInsert(LN* pos, LDataType x)
{

	assert(pos);
	LN* newnode = BuyLN(x);
	LN* prev = pos->head;

	pos->head = newnode;
	newnode->tail = pos;
	newnode->head = prev;
	prev->tail = newnode;
}

任意位置删除LNErase

和上面一样，要删除哪个元素，就要先找到那个元素，然后进行删除操作，找到那个元素的任务依旧交给LNFind函数

void LNErase(LN* pos)
{
	assert(pos);
	LN* ne = pos->head;

	pos->head = ne->head;
	ne->tail = pos;
}

测试结果

测试代码：

#include "List.h"

void TestLN()
{
	LN* plist = NULL;
	LNInit(&plist);
	LNPrint(plist);

	LNPushBack(plist, 1);
	LNPushBack(plist, 2);
	LNPushBack(plist, 3);
	LNPushBack(plist, 4);
	LNPushBack(plist, 5);
	LNPrint(plist);


	LNPopBack(plist);


	LNPrint(plist);

	LNPushFront(plist, -1);
	LNPushFront(plist, -2);
	LNPushFront(plist, -3);
	LNPushFront(plist, -4);
	LNPushFront(plist, -5);


	LNPrint(plist);
	LNPopFront(plist);

	LNPrint(plist);

	LN* ret = LNFind(plist, 3);
	if (ret != NULL)
	{
		cout << ret->val << ' ' << ret << endl;
		LNInsert(ret, 10000);
		LNErase(ret);
	}
	LNPrint(plist);


	LNDestory(plist);
}

int main()
{
	TestLN();

	return 0;
}

在这里插入图片描述

源代码

.h文件

#pragma once


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

using namespace std;

typedef int LDataType;

typedef struct ListNode
{
	LDataType val;
	struct ListNode* head;
	struct ListNode* tail;
}LN;

LN* BuyLN(LDataType x);//为要插入的值开辟一块空间

void LNInit(LN** pphead);//初始化
void LNDestory(LN* phead);//销毁

void LNPrint(LN* phead);//打印链表中的值

void LNPushBack(LN* phead, LDataType x);//尾插
void LNPopBack(LN* phead);//尾删

void LNPushFront(LN* phead, LDataType x);//头插
void LNPopFront(LN* phead);//头删

bool LNEmpty(LN* phead);//双链表是否为空

LN* LNFind(LN* phead, LDataType x);//查找

void LNInsert(LN* pos, LDataType x);//任意位置插入
void LNErase(LN* pos);//任意位置删除

.cpp文件

#include "List.h"

LN* BuyLN(LDataType x)
{
	LN* sn = (LN*)malloc(sizeof(LN));
	if (sn == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	sn->val = x;
	sn->head = NULL;
	sn->tail = NULL;

	return sn;
}

void LNPrint(LN* phead)
{
	assert(phead);
	LN* sn = phead->head;
	while (sn != phead)
	{
		cout << sn->val << ' ';
		sn = sn->head;
	}
	cout << endl;
}

void LNInit(LN** pphead)//ʼ
{
	(*pphead) = BuyLN(-1);
	(*pphead)->head = *pphead;
	(*pphead)->tail = *pphead;
}



void LNDestory(LN* phead)//ٿռ
{
	assert(phead);

	LN* cur = phead->head;


	while (cur != phead)
	{
		LN* sn = cur;
		free(sn);
		sn = NULL;
		cur = cur->head;

	}
}

void LNPushBack(LN* phead, LDataType x)
{
	LN* newnode = BuyLN(x);
	LN* prev = phead->tail;

	prev->head = newnode;
	newnode->tail = prev;
	newnode->head = phead;
	phead->tail = newnode;
}

void LNPopBack(LN* phead)
{
	assert(phead->head != phead->tail);
	LN* prev = phead->tail;

	prev->tail->head = phead;
	phead->tail = prev->tail;
	free(prev);
	prev = NULL;
}



void LNPushFront(LN* phead, LDataType x)
{
	LN* newnode = BuyLN(x);
	LN* ne = phead->head;

	ne->tail = newnode;
	newnode->head = ne;
	phead->head = newnode;
	newnode->tail = phead;
}

void LNPopFront(LN* phead)
{
	assert(phead->head != phead->tail);

	LN* ne = phead->head;
	phead->head = ne->head;
	ne->head->tail = phead;
	free(ne);
	ne = NULL;

}

bool LNEmpty(LN* phead)
{

	assert(phead);
	return phead->head == phead->tail;
}

LN* LNFind(LN* phead, LDataType x)
{
	assert(phead);
	assert(phead->head != phead->tail);

	LN* cur = phead->head;

	while (cur != phead)
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->head;
	}
	return NULL;
}

void LNInsert(LN* pos, LDataType x)
{

	assert(pos);
	LN* newnode = BuyLN(x);
	LN* prev = pos->head;

	pos->head = newnode;
	newnode->tail = pos;
	newnode->head = prev;
	prev->tail = newnode;
}

void LNErase(LN* pos)
{
	assert(pos);
	LN* ne = pos->head;

	pos->head = ne->head;
	ne->tail = pos;
}

test.cpp文件

#define _CRT_SECURE_NO_WARNINGS 1


#include "List.h"

void TestLN()
{
	LN* plist = NULL;
	LNInit(&plist);
	LNPrint(plist);

	LNPushBack(plist, 1);
	LNPushBack(plist, 2);
	LNPushBack(plist, 3);
	LNPushBack(plist, 4);
	LNPushBack(plist, 5);
	LNPrint(plist);


	LNPopBack(plist);


	LNPrint(plist);

	LNPushFront(plist, -1);
	LNPushFront(plist, -2);
	LNPushFront(plist, -3);
	LNPushFront(plist, -4);
	LNPushFront(plist, -5);


	LNPrint(plist);
	LNPopFront(plist);

	LNPrint(plist);

	LN* ret = LNFind(plist, 3);
	if (ret != NULL)
	{
		cout << ret->val << ' ' << ret << endl;
		LNInsert(ret, 10000);
		LNErase(ret);
	}
	LNPrint(plist);


	LNDestory(plist);
}

int main()
{
	TestLN();

	return 0;
}
Kai2026
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
【数据结构】双链表
m0_62531913的博客
08-15 1339
数据结构中的双链表
双链表
cqc1161的博客
11-19 360
双链表 一、实验目的 巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二、实验内容 建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 三、详细设计（C++） 1.算法设计 定义顺序表的数据类型——双链表类，包括插入、删除、查找、遍历等基本操作。
数据结构-双链表(图解)
最新发布
2302_78381559的博客
04-20 1499
双链表是一种常用且重要的线性数据结构，它在计算机科学和软件工程中扮演着不可或缺的角色。相较于单链表，双链表的每个节点包含两个指针，分别指向其前驱节点（previous node）和后继节点（next node），这一特性使得双链表在数据操作上具有更高的灵活性。
数据结构-双向链表
04-14
完整双向链表的实现代码，包括了线性表的基本操作:插入、删除、访问和查找
链表-使用PHP实现的双向链表数据结构.zip
03-13
链表 链表_使用PHP实现的双向链表数据结构
数据结构-双链表.c
10-16
数据结构-双链表.c
数据结构-双向循环链表
10-23
双向循环链表的节点结构包含三个部分：数据域、前驱指针和后继指针。其中，前驱指针指向前一个节点，后继指针指向后一个节点。在双向循环链表中，头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。 双向...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值