双向链表的功能实现

最新推荐文章于 2024-04-14 23:29:03 发布
最新推荐文章于 2024-04-14 23:29:03 发布
阅读量744 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64707620/article/details/130624449
版权

      前言：我们已经学习并知道了单链表的实现，链表的实现方式不只是单链表一种，今天我们就来介绍一种新的结构，就是双链表结构，本质上是将节点间进行双向链接，从而使一些操作更加容易实现。

目录

1.双向链表的简介

2.双向链表的实现

带头节点的哨兵位的创建和初始化

为什么要使用哨兵位？

节点的头、尾插和头、尾删

插入和删除函数

完整程序代码及测试代码

List.h

List.cpp

Test.cpp

3.金句频道

1.双向链表的简介

        双向链表（Doubly Linked List）是一种常见的线性数据结构，它相比于单向链表多了一个指针，可以支持双向遍历。

       每个节点在双向链表中都有两个指针，一个指向前一个节点，一个指向后一个节点，因此可以从任意一个节点开始，依次遍历前一个节点和后一个节点。双向链表可以对数据进行插入和删除操作，这些操作相比较单向链表来说更加方便和高效。

 双向链表的特点包括：

1. 每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点。
2. 可以从任意一个节点开始，依次遍历前一个节点和后一个节点。
3. 可以对数据进行插入和删除操作，保证了操作的高效性和方便性。
4. 相对于单向链表来说，占用更多的存储空间，因为需要多一个指针来指向前一个节点。

     

      需要注意的是，当插入或删除一个节点时，需要同时修改其前后两个节点的指针，才能保证链表结构的完整性。

2.双向链表的实现

带头节点的哨兵位的创建和初始化

为什么要使用哨兵位？

       链表中哨兵位（Sentinel）是一种特殊的节点，位于链表头部或尾部，不存储任何实际的数据。引入哨兵位的主要目的是为了简化链表的操作，提高代码的可读性和可维护性。

使用哨兵位的优点主要包括：

1. 简化代码逻辑：引入哨兵位后，链表的头尾节点都指向哨兵位而不是NULL，这样在任何情况下，我们都不需要对头尾节点进行特判，也不需要用二级指针进行传址了(链表中引入二级指针的目的，其实就是为了在头结点为空的情况下，节点还能正常创建并使用，说白了就是为了“对NULL指针进行解引用操作”）。这样能够简化代码逻辑，减少代码复杂度，提高代码可读性和可维护性。

2. 避免空指针异常：使用哨兵位可以避免在链表为空或链表操作时出现空指针异常。如果没有哨兵位，我们需要在头尾节点为空时进行特判，否则可能会导致程序崩溃。

LTNode* LTInit()
{
	Listnode head = (Listnode)malloc(sizeof(LTNode));
	assert(head);//断言，防止开辟不成功
	head->data = -1;
	//初始让头结点的前驱和后继都指向自己，这样可以便与判断链表是否为空并且与尾结点指向哨兵位的操作上统一
	head->next = head->prev = head;
	return head;
}

节点的头、尾插和头、尾删

        这些操作基本与单链表的操作大同小异，只是多了一个前驱结点的操作，这里需要注意以下几点：

1.注意对可能为NULL的指针进行断言避免出现野指针和堆错误问题；

2.对不再使用的空间进行及时的释放，避免内存泄漏。

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	
	assert(phead);
	LTNode* newnode = new LTNode(x);
	LTNode* first = phead->next;

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

	newnode->next = first;
	first->prev = newnode;
	

	//LTInsert(phead->next, x);
}

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

	//这里最好将两个及以上解引用的操作分开
	LTNode *first = phead->prev;
	first->next = newnode;
	newnode->next = phead;
	newnode->prev = first;
	phead->prev = newnode;

	//或者可以直接调用插入函数
	//LTInsert(phead, x);
}

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

	free(p);
	phead->next=ppnext;
	ppnext->prev=phead;
	
	//LTErase(phead->next);
}

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
	

	//LTErase(phead->prev);
}

       细心地朋友可能已经注意到了，这些不同的函数内部都有相同的LTInsert或LTErase函数，这不是偶然，我们将不同方式插入或删除的函数进行对比，就会发现，它们的代码具有一定的逻辑重复性，存在逻辑上互通的部分，我们可以将这个部分归纳为一个函数，像头插和尾插，我们可以写一个在任意节点前或后插入的函数，再将不同的节点需要的参数分别传入，就能实现不同的功能，尾删和头删也是同理，这样就大大简化了代码，减少了使用指针出错的可能性。

插入和删除函数

// 在pos之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);//断言，判断pos是否合法

	Listnode newnode = new LTNode(x);
	Listnode pre = pos->prev;
	pre->next = newnode;
	newnode->next = pos;
	newnode->prev = pre;
	pos->prev = newnode;

}

// 删除pos位置的值
void LTErase(LTNode* pos)
{
	assert(pos);
	Listnode front = pos->prev;
	Listnode behind = pos->next;
	front->next = behind;
	behind->prev = front;
	free(pos);
	pos = NULL;
}

完整程序代码及测试代码

List.h

#pragma once

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

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
	//C++构造函数//可不写
	ListNode(LTDataType d = 0, ListNode* pr = NULL, ListNode* ne = NULL)
	{
		data = d, prev = pr, next = ne;
	}
}LTNode,*Listnode;

//创建并初始化头结点
LTNode* LTInit();

//打印带头结点的单链表
void LTPrint(LTNode* phead);

//判断链表是否为空
bool LTEmpty(LTNode* phead);

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

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

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

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

//查找值为x的节点
LTNode* LTFind(LTNode* phead, LTDataType x);

// 在pos之前插入
void LTInsert(LTNode* pos, LTDataType x);

// 删除pos位置的值
void LTErase(LTNode* pos);

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

List.cpp

#include <bits/stdc++.h>
#include "List.h"
using namespace std;

LTNode* LTInit()
{
	Listnode head = (Listnode)malloc(sizeof(LTNode));
	assert(head);//断言，防止开辟不成功
	head->data = -1;
	//初始让头结点的前驱和后继都指向自己
	head->next = head->prev = head;
	return head;
}
void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("guard");
	Listnode p = phead->next;
	while (p!= phead)
	{
		printf("->%d", p->data);
		p = p->next;
	}
	printf("\n");
}

// 在pos之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);//断言，判断pos是否合法

	Listnode newnode = new LTNode(x);
	Listnode pre = pos->prev;
	pre->next = newnode;
	newnode->next = pos;
	newnode->prev = pre;
	pos->prev = newnode;

}
bool LTEmpty(LTNode* phead)
{
	return phead->next == phead;
}
void LTPushBack(LTNode* phead, LTDataType x)
{
	Listnode newnode = new LTNode(x);

	//这里最好将两个及以上解引用的操作分开
	LTNode *first = phead->prev;
	first->next = newnode;
	newnode->next = phead;
	newnode->prev = first;
	phead->prev = newnode;

	//或者可以直接调用插入函数
	//LTInsert(phead, x);
}
void LTPushFront(LTNode* phead, LTDataType x)
{
	
	assert(phead);
	LTNode* newnode = new LTNode(x);
	LTNode* first = phead->next;

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

	newnode->next = first;
	first->prev = newnode;
	

	//LTInsert(phead->next, x);
}
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	free(tail);
	tailPrev->next = phead;
	phead->prev = tailPrev;
	

	//LTErase(phead->prev);
}
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));
	
	LTNode* p = phead->next;
	LTNode* ppnext = p->next;

	free(p);
	phead->next=ppnext;
	ppnext->prev=phead;
	
	//LTErase(phead->next);
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	Listnode p = phead->next;
	while (p!= phead)
	{
		if (p->data == x)
			return p;
		p = p->next;
	}
	return NULL;
}


// 删除pos位置的值
void LTErase(LTNode* pos)
{
	assert(pos);
	Listnode front = pos->prev;
	Listnode behind = pos->next;
	front->next = behind;
	behind->prev = front;
	free(pos);
	pos = NULL;
}
void LTDestroy(LTNode* phead)
{
	
	assert(phead);
	LTNode* cur = (phead)->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;//此处传的是一级指针，在外部函数内修改没有作用,应该传二级指针或者在主函数内进行销毁,这里我们选择在主函数内单独进行置空
}

Test.cpp

#include <bits/stdc++.h>
#include "List.h"
using namespace std;

void TestList1()
{
	LTNode* plist = LTInit();
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);

	LTPrint(plist);

	LTPopBack(plist);
	LTPrint(plist);

	LTPopBack(plist);
	LTPrint(plist);

	LTPopBack(plist);
	LTPrint(plist);

	LTPopBack(plist);
	LTPrint(plist);

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

	LTDestroy(plist);
	plist = NULL;
}

void TestList2()
{
	LTNode* plist = LTInit();
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

	LTPopFront(plist);
	LTPrint(plist);

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

	LTDestroy(plist);
	plist = NULL;
}

void TestList3()
{
	LTNode* plist = LTInit();
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);
	LTPrint(plist);

	LTNode* pos = LTFind(plist, 3);
	if (pos)
	{
		LTInsert(pos, 30);
	}
	LTPrint(plist);

	LTDestroy(plist);
	plist = NULL;
}

int main()
{
	TestList1();
	TestList2();
	TestList3();

	return 0;
}

3.金句频道

      最近看到这样一句话：“当我真正开始爱自己，我睡的越来越早，也越来越喜欢锻炼。我不在纠结和焦虑，变得自信满满，去追求有意义的人和事，并为之燃烧自己的热情。我发现，人生才刚刚开始.”

 

Lee贤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——双向链表（双向连接的图解、双向链表的创建、操作双向链表）
qq_52301431的博客
08-23 4077
举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢?- 我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况。- 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.- 一个节点既有向前连接的引用, 也有一个向后连接的引用.- 既可以从头遍历到尾, 又可以从尾遍历到头。
C++实现双向链表
fzy2003的博客
04-15 4364
实现双向链表的基本操作：创建列表功能，插入功能，删除功能，顺序输出，逆序输出，判断回文串功能 #include <iostream> #include<cstring> using namespace std; class ListNode { public: char data; ListNode* prev; ListNode* next; ListNode() { data = '0'; prev = nullptr; next = nullptr;
C语言双向循环链表
qq_45911878的博客
08-07 4343
C语言单向链表正向、反向、排序插入和链表逆转。
双向链表的实现（详解）
最新发布
的博客
04-14 519
链表的分类： 带头 不带头 单向 双向 循环 不循环一共有 (2 * 2 * 2) 种链表带头指的是：带有哨兵位节点哨兵位（头结点）：可以放随机数据，哨兵位指向的下一个节点就是我们的第一个有效节点，我们指的头节点是哨兵位单向：指针只能从前向后遍历双向：指针既可以从前向后遍历又可以从后向前遍历循环：可以通过尾节点找到头节点，从而达到循环主要使用的链表是单链表和双向链表单链表:不带头单向不循环双向链表：带头双向循环。
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 4985
本文详细介绍带头双向循环链表，内容较为丰富
C++的双向链表实现
04-15
这些IDE提供了C++的开发环境，包括代码编辑、编译和调试功能，使得编写、测试和调试双向链表实现变得容易。 总的来说，理解和掌握C++中的双向链表是学习数据结构和算法的重要步骤。通过实践操作，你可以更好地理解...
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素 9.将游标重置指向链表中...
双向链表C语言实现
12-13
本文将详细讲解如何使用C语言来实现一个双向链表，并涵盖按照ID序列插入、删除、更新和修改等操作。 双向链表与单链表不同，它在每个节点中不仅存储数据，还包括指向前后节点的指针。这种特性使得双向链表可以在...
双向链表的实现
05-16
此外，双向链表在需要快速访问相邻元素或者需要反向遍历数据时特别有用，例如在实现迭代器或某些排序算法（如插入排序）时。 在C++中，我们可以自定义一个结构体或类来表示链表的节点，通常包含数据域和两个指针域...
数据结构——双向链表的实现
zhoubancheng的博客
10-30 734
三、顺序表和双向链表的优缺点分析注意：双向链表又称带头双向循环链表这⾥的“带头”跟前⾯我们说的“头节点”是两个概念，实际前⾯的在单链表阶段称呼不严谨，但是为了同学们更好的理解就直接称为单链表的头节点。带头链表⾥的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这⾥“放哨的”哨兵位”存在的意义：遍历循环链表避免死循环。双向链表每个节点储存一个有效数据+前驱指针+后继指针。
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
创建双向链表
Minus_zero的博客
11-27 1434
** 创建双向链表 单项链表节点的存储结构只有一个指向直接后继的指针域，所以从链表的某个节点出发只能顺指针查找其他节点。使用双向链表可以避免单项链表这种单项性的缺点。 顾名思义，双向链表的节点有两个指针域，一个指向其直接后继；另一个指向其直接前驱。`` #include<stdio.h> #include<malloc.h> #include<string.h> #include <string> //声明struct node 类型，代码如下：
【数据结构】双向链表的遍历、添加、修改和删除
dengmsjava的博客
05-12 2488
双向链表的遍历、添加、修改和删除 （1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 （2）单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除。
双向链表的创建
Lianuuu的博客
05-17 1932
文章目录1. 什么是双向链表2. 双向链表的创建 1. 什么是双向链表 双向链表含有两个指针域，分别指向当前节点的直接前驱节点和直接后继节点，双向链表适合需要大量地找某指定结点的前趋结点的情况: 双向链表中各节点包含以下 3 部分信息，如下图所示： 指针域：用于指向当前节点的直接前驱节点； 数据域：用于存储数据元素； 指针域：用于指向当前节点的直接后继节点。 因此，双链表的节点结构用 C 语言实现为： typedef struct line { struct line * prior; /
c语言简单实现双向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-18 2622
c语言最简单实现双向链表
4.C++实现双向链表
Firenze__的博客
07-14 253
习题4.用C++实现一个双向链表 4.用C++实现一个双向链表 struct Node { int data; Node * pre; Node * next; }; 逆置一个单链表 逆置双向链表 class List { public: List(); ~List(); void push_front(int data);//在头部进行插入 void push_back(int d
如何使用一个指针来实现双向链表操作
chiichen的专栏
08-08 6918
1、使用的数学基础和基本数据结构及关系： x ^ y ^ y = x ^ ( y ^ y ) = x ^ 0 = x 双指针双向链表结点： struct double_link_list { struct double_link_list *next;
使用C语言实现双向链表的全部功能
04-05
以下是使用C语言实现双向链表的全部功能的代码： ```c #include #include // 定义双向链表的节点结构体 typedef struct Node { int data; struct Node* prev; struct Node* next; } Node; // 初始化双向链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值