双向链表的实现

于 2022-11-21 10:52:51 发布
阅读量832 收藏 5
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yntic/article/details/127944831
版权

目录

一，链表的概念及结构

二，双向链表的实现

        ①单个节点的创建及其初始化

        ②接口函数——尾部节点插入和删除的实现

        ③接口函数——头部节点的插入和删除

        ④接口函数——找到指定数字节点位置并进行其增删

        ⑤接口函数——链表销毁

三，整体代码

一，链表的概念及结构

        什么是链表呢？链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。没错，链表的逻辑结构像极了我们生活中的火车，一个节点连着一个节点，各个节点之间靠指针来指向传递。

        链表有多种结构，由六种情况可以分为八种链表结构，虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：①无头单向非循环链表、②带头双向循环链表。

        在这里我将介绍带头双向循环链表来给大家（在这里我们简称为双向链表）。图示如下，我们依旧将该项目拆分为DList.c、DList.h、Test.c三个部分来封装实现。链表的接口函数放在DList.c文件中。

二，双向链表的实现

我们需要的节点有如下作用：

1，有一个prev指针指向该节点的前一个节点

2，有一个next指针指向该节点的后一个节点

3，需要一个头节点

4，需要尾指针的next节点指向哨兵位头节点以达成循环状态。

        ①单个节点的创建及其初始化

        首先我们需要定义单个节点，对于这个节点来说：我们需要一个指针指向下一个节点、同样需要一个指针指向前一节点，当然不能忘了存储数据。基本实现如下：

typedef int DLDatatype;//重命名变量类型以便后续修改
typedef struct DListNode//重命名结构体以便简单操作传参
{
	struct DListNode* prev;//指向前一节点
	struct DListNode* next;//指向后一节点
	DLDatatype data;//放置数据
}DList;

        在这里我们首先选在创建一个节点，实现如下：

//开辟一个节点
DList* BuyListNode(DLDatatype x)
{
	DList* newnode = (DList*)malloc(sizeof(DList));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

        在如上操作后我们首先实现头结点的创建，我们假设链表中没有数据，于是我们需要头结点的next指针指向自己，prev指针也指向自己构成循环

//头节点初始化
DList* DLSInit()
{
	DList* phead = BuyListNode(0);//我们将头结点的值设为0
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

 可以观察到我们的prev与head都成功指向自己构成循环的头节点。

        ②接口函数——尾部节点插入和删除的实现

如同我们链表一般，我们可以在向链表进行插入新的节点和删除原有节点。思路如下：

在头结点中，我们的prev节点指向phead自己，next也是指向phead自己，所以插入新的节点时我们是从头节点开始插入。当传进去的节点可能为空时，我们就不能插入数据，所以这里我们需要对节点断言是否为空。

增加新节点：1，开辟新节点；2，找到尾节点；3，开始插入，插入的时候只需要按照双向链表的循环规则即可实现。

代码如下：

void DLPushBack(DList* phead, DLDatatype x)
{
	assert(phead);//不要忘了断言phead是否为空哦
	DList* newnode = BuyListNode(x);
	DList* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

为了显示链表插入情况，我们封装一个打印函数来展现效果。

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

效果如下：

 完成插入新节点后，我们再来实现删除节点这一操作。这时我们需要注意：

1.我们不能删除哨兵位的头节点，这是我们进行循环链表实现的基础，所以我们需要对头结点的next是否等于头节点进行判断。如果它指向自己，证明链表仅头节点——不可继续删除

2.删除尾节点时需要找到尾节点的前一个结点——也就是prev指向的节点，然后再进行尾节点删除。

3.由于我们的节点都是动态开辟，所以需要使用free函数来自主释放空间。

代码如下：

void DLPopBack(DList* phead)
{
	assert(phead->next != phead);
	DList* tail = phead->prev;
	DList* tailprev = tail->prev;
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
}

 效果如下：

 注意我们红圈部分，由于在进行四次删除之后链表已经只剩了头节点，所以第四次删除后调用打印函数时没有进入循环，直接打印了换行。如果再次删除——也就是头节点，就会报错。 

         ③接口函数——头部节点的插入和删除

        注意这里的头部指的是头节点之后的位置，而不是头节点前。由于我们节点双指针的存在，进行这一操作确实简单。

头部插入：①开辟新的节点；②找到头结点的下一个节点；③进行插入(当然不要忘了判断节点是否为空）

代码如下：（这里我们实现完删除后统一展现效果）

void DLPushFront(DList* phead, DLDatatype x)
{
	assert(phead);
	DList* newhead = BuyListNode(x);
	DList* cur = phead->next;
	newhead->next = cur;
	cur->prev = newhead;
	newhead->prev = phead;
	phead->next = newhead;
}

头部删除逻辑依旧跟尾部删除相似：删除头结点的next节点，保存next节点的next节点。

代码如下：

void DLPopFront(DList* phead)
{
	assert(phead);
	assert(phead->next != phead);//不删除哨兵位
	DList* cur = phead->next;
	DList* curnext = cur->next;
	phead->next = curnext;
	curnext->prev = phead;
	free(cur);

}

效果如下：

         ④接口函数——找到指定数字节点位置并进行其增删

        链表当然缺少不了指定数据节点的增删这一操作，双向链表依然如此，所以我们需要实现指定的节点进行操作，首先是得找到指定数字的节点，我们在这里假设为pos节点。

        从头结点的下一个节点开始遍历链表，直指最后一个节点的next指针指向phead时停止，找到就返回这一节点，失败返回NULL。

代码如下：

DList* DListFind(DList* phead,DLDatatype x)
{
	DList* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

 我们修改其date数值来操作观察，效果如下：

 如果我们要需要删除pos节点位置，思路如下
①检验pos节点是否为空；②让pos的prev处节点和next处节点链接即可

代码实现如下：

//删除pos位置
void DLErase(DList* pos)
{
	assert(pos);
	DList* prev = pos->prev;
	DList* next = pos->next;
	free(pos);
	prev->next = next;
	next->prev = prev;
}

效果展示：

 这时我们依然可以发现，如果要进行头部尾部删除时，只需要传入phead的prev进行尾部删除，传入phead的next进行头部删除就可以实现。

 可以进行之前删除操作，效果如下

头部删除：

 尾部删除：

 这时我们需要封装一个新的函数——pos节点前的增添函数

实现思路：

①开辟新节点；②保存pos的前一节点；③将新节点插入在pos前一节点和pos之间

代码实现如下：

//在pos之前插入x
void DLInsert(DList* pos,DLDatatype x)
{
	assert(pos);
	DList* prev = pos->prev;
	DList* newnode = BuyListNode(x);
	newnode->next = pos;
	pos->prev = newnode;
	prev->next = newnode;
	newnode->prev = prev;

效果展示：

 这时我们依旧可以观察到，当我们进行头部尾部节点的插入时，也只需这一个函数即可。

观察下图，我们进行尾部插入时，只需要传入phead即可，因为phead前一个节点就是tail——这时就是尾插。我们进行头部插入是，需要传入phead的next处节点即可，这时就可以进行头部插入。

 

 效果如下：

头部插入：

尾部插入：

         ⑤接口函数——链表销毁

        由于我们的节点是动态开辟出，在我们不使用时需要进行自主释放，为避免造成野指针和空间泄露。所以我们需要创建一个函数来实现。思路如下：

①保存头节点的下一个节点；②对之后的节点逐一释放空间即可。

//销毁链表
void DLDestroy(DList* phead)
{
	assert(phead);

	DList* cur = phead->next;
	while (cur != phead)
	{
		DList* next = cur->next;
		free(cur);

		cur = next;
	}

	free(phead);
	//phead = NULL;
}

 

三，整体代码

//DList.c文件
//开辟一个节点
DList* BuyListNode(DLDatatype x)
{
	DList* newnode = (DList*)malloc(sizeof(DList));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

//链表初始化
DList* DLSInit()
{
	DList* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}


//打印链表
void DListPrint(DList* phead)
{
	assert(phead);
	DList* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ",cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//尾插尾删
void DLPushBack(DList* phead, DLDatatype x)
{	assert(phead);
	//DList* newnode = BuyListNode(x);
	//DList* tail = phead->prev;
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;
	DLInsert(phead, x);
}
void DLPopBack(DList* phead)
{
	assert(phead->next != phead);
	//DList* tail = phead->prev;
	//DList* tailprev = tail->prev;
	//tailprev->next = phead;
	//phead->prev = tailprev;
	//free(tail);
	DLErase(phead->prev);
}
//头插头删
void DLPushFront(DList* phead, DLDatatype x)
{
	assert(phead);
	//DList* newhead = BuyListNode(x);
	//DList* cur = phead->next;
	//newhead->next = cur;
	//cur->prev = newhead;
	//newhead->prev = phead;
	//phead->next = newhead;
	DLInsert(phead->next, x);
}
void DLPopFront(DList* phead)
{
	assert(phead);
	assert(phead->next != phead);//不删除哨兵位
	//DList* cur = phead->next;
	//DList* curnext = cur->next;
	//phead->next = curnext;
	//curnext->prev = phead;
	//free(cur);
	DLErase(phead->next);
}

//找到指定数字的节点
DList* DListFind(DList* phead,DLDatatype x)
{
	DList* cur = phead->next;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

//在pos之前插入x
void DLInsert(DList* pos,DLDatatype x)
{
	assert(pos);
	DList* prev = pos->prev;
	DList* newnode = BuyListNode(x);
	newnode->next = pos;
	pos->prev = newnode;
	prev->next = newnode;
	newnode->prev = prev;
}

//删除pos位置
void DLErase(DList* pos)
{
	assert(pos);
	DList* prev = pos->prev;
	DList* next = pos->next;
	free(pos);
	prev->next = next;
	next->prev = prev;
}
//销毁链表
void DLDestroy(DList* phead)
{
	assert(phead);

	DList* cur = phead->next;
	while (cur != phead)
	{
		DList* next = cur->next;
		free(cur);

		cur = next;
	}

	free(phead);
	//phead = NULL;
}

//DList.h文件
#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include <stdbool.h>
typedef int DLDatatype;

typedef struct DListNode
{
	struct DListNode* prev;
	struct DListNode* next;
	DLDatatype data;
}DList;
//初始化哨兵位头节点
DList* DLSInit();

//打印链表
void DListPrint(DList* phead);

//尾插尾删
void DLPushBack(DList* phead,DLDatatype x);
void DLPopBack(DList* phead);

//头插头删
void DLPushFront(DList* phead, DLDatatype x);
void DLPopFront(DList* phead);

//找寻节点
DList* DListFind(DList* phead, DLDatatype x);

//在pos前插入x
void DLInsert(DList* phead, DLDatatype x);

//删除pos节点
void DLErase(DList* pos);

//销毁
void DLDestroy(DList* phead);

Yntic
关注
专栏目录
双向链表实现
hxy1625309592的博客
12-15 2182
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
数据结构——双向链表
最新发布
zoelinkailuo的博客
10-03 824
/指针保存下一个结点的地址//指针保存前一个结点的地址}LTNode;
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语言版）
12-26
在本文中，我们将深入探讨如何使用C语言和双向链表实现经典的贪吃蛇游戏。双向链表是一种数据结构，它允许我们在列表中的任何位置轻松地插入和删除元素，这使得它成为实现动态游戏世界，如贪吃蛇，的理想选择。 1. ...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
数据结构之双向链表的实现
qq_62905847的博客
10-02 854
java自主实现双向链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值