用C++类实现 双向非循环带头结点的链表

最新推荐文章于 2021-12-09 22:39:29 发布
原创 最新推荐文章于 2021-12-09 22:39:29 发布 · 315 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#双向非循环带头结点 #链表 #c++实现 #双向非循环

本文介绍了如何使用C++通过类来实现双向非循环带头结点的链表，并在此基础上添加了模板功能。通过将Node改造成模板类Node<T>，并替换成员函数中的内置类型为T，允许程序员在实例化时自定义数据类型。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

双向非循环带头结点的链表

在这里插入图片描述
图好像有点丑~~在这里插入图片描述

下列是相关操作的代码（C++ 类封装）

#pragma once
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;

//对一个结点进行封装
class Node {
public:
	Node* _next;
	Node* _pre;
	int _data;
};

//双向非循环链表
class SList {
public:
	SList(){
		_head = new Node;
		
		_head->_pre = nullptr;
		_head->_next = nullptr;
		_head->_data = 0;
	}
	~SList() {
		delete _head;
		_head = nullptr;
	}
	//尾插
	void SListPushBack(int data) {
		Node* node = new Node;
		node->_data = data;

		//只存在头结点
		if (_head->_next == nullptr) {
			node->_pre = _head;
			node->_next = nullptr;
			_head->_next = node;
		}
		else {

			//找到最后一个结点
			Node* cur = _head->_next;
			while (cur->_next != nullptr) {
				cur = cur->_next;
			}
			//进行插入
			node->_next = nullptr;
			node->_pre = cur;
			cur->_next = node;
		}
	}
	//尾删
	void SListPopBack() {
		if (_head->_next == nullptr) {
			return;
		}

		//找到倒数第二个结点
		Node* cur = _head->_next;
		while (cur->_next->_next != nullptr) {
			cur = cur->_next;
		}
		Node* node = cur->_next;
		node->_pre = nullptr;
		delete node;
		cur->_next = nullptr;
	}
	//头插
	void SListPushFront(int data) {
		Node* node = new Node;
		node->_data = data;
	
		//如果只有头结点 
		if (_head->_next == nullptr) {
			node->_next = nullptr;
			node->_pre = _head;
			_head->_next = node;
		}
		//至少有一个结点
		node->_next = _head->_next;
		node->_pre = _head;
		_head->_next->_pre = node;
		_head->_next = node;
	}
	//头删
	void SListPopFront() {
		if (_head->_next == nullptr) {
			return;
		}
		if (_head->_next->_next == nullptr) {
			Node* cur = _head->_next;
			cur->_pre = nullptr;
			delete cur;
			_head->_next = nullptr;
		}

		//至少有两个结点
		Node* node = _head->_next->_next;
		Node* cur = _head->_next;
		_head->_next = node;
		node->_pre = _head;
		cur->_next = cur->_pre = nullptr;
		delete cur;
	}

	//在 pos 结点前面插入
	void SListInsertFront(Node* pos,int data) {
		Node* node;
		node->_data = data;
		
		node->_next = pos;
		node->_pre = pos->_pre;
		pos->_pre->_next = node;
		pos->_pre = node;
	}
	//在 pos 结点后面插入
	void SListInsertAfter(Node* pos, int data) {
		Node* node;
		node->_data = data;

		node->_pre = pos;
		node->_next = pos->_next;
		pos->_next->_pre = node;
		pos->_next = node;
	}

	//删除 pos 结点
	void SListErase(Node* pos) {
		//只有头结点或只剩下最后一个结点
		if (pos->_next == nullptr) {
			Node* pre = pos->_pre;
			pre->_next = nullptr;
			pos->_pre = nullptr;
			delete pos;
		}else{
			Node* pre = pos->_pre;
			pre->_next = pos->_next;
			pos->_next->_pre = pre;
			pos->_next = pos->_pre = nullptr;
			delete pos;
		}
	}

	//查找结点
	int SListFind(int data) {
		Node* node = _head->_next;
		while (node != nullptr) {
			if (node->_data == data) {
				return 1;
			}
			node = node->_next;
		}
		return 0;
	}
	//删除v所对应的结点
	void SListEraseV(int data) {
		Node* node = _head->_next;
		while (node != nullptr) {
			if (node->_data == data) {
				Node* next = node->_next;
				SListErase(node);
				node = next;
			}else {
				node = node->_next;
			}
		}
	}

	void Print() {
		Node* node = _head->_next;
		while (node != nullptr) {
			cout << node->_data<<" ";
			node = node->_next;
		}
		cout << endl;
	}
private:
	Node* _head;
};

在此基础上添加模板

其实变化几乎不是很大，就是把Node 改成了 Node < T >,把成员函数中出现的 内置类型，比如 ：int float 都改为 T ，这个T是程序猿在实例化的时候自定义类型。

#pragma once
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;

//对一个结点进行封装
template<class T>
class Node {
public:
	Node<T>* _next;
	Node<T>* _pre;
	int _data;
};

//双向非循环链表
template<class T>
class SList {
public:
	SList(){
		_head = new Node<T>; 
		_head->_pre = nullptr;
		_head->_next = nullptr;
		_head->_data = 0;
	}
	~SList() {
		delete _head;
		_head = nullptr;
	}
	//尾插
	void SListPushBack(int data) {
		Node<T>* node = new Node<T>;
		node->_data = data;

		//只存在头结点
		if (_head->_next == nullptr) {
			node->_pre = _head;
			node->_next = nullptr;
			_head->_next = node;
		}
		else {

			//找到最后一个结点
			Node<T>* cur = _head->_next;
			while (cur->_next != nullptr) {
				cur = cur->_next;
			}
			//进行插入
			node->_next = nullptr;
			node->_pre = cur;
			cur->_next = node;
		}
	}
	//尾删
	void SListPopBack() {
		if (_head->_next == nullptr) {
			return;
		}

		//找到倒数第二个结点
		Node<T>* cur = _head->_next;
		while (cur->_next->_next != nullptr) {
			cur = cur->_next;
		}
		Node<T>* node = cur->_next;
		node->_pre = nullptr;
		delete node;
		cur->_next = nullptr;
	}
	//头插
	void SListPushFront(int data) {
		Node<T>* node = new Node<T>;
		node->_data = data;
	
		//如果只有头结点 
		if (_head->_next == nullptr) {
			node->_next = nullptr;
			node->_pre = _head;
			_head->_next = node;
		}
		//至少有一个结点
		node->_next = _head->_next;
		node->_pre = _head;
		_head->_next->_pre = node;
		_head->_next = node;
	}
	//头删
	void SListPopFront() {
		if (_head->_next == nullptr) {
			return;
		}
		if (_head->_next->_next == nullptr) {
			Node<T>* cur = _head->_next;
			cur->_pre = nullptr;
			delete cur;
			_head->_next = nullptr;
		}

		//至少有两个结点
		Node<T>* node = _head->_next->_next;
		Node<T>* cur = _head->_next;
		_head->_next = node;
		node->_pre = _head;
		cur->_next = cur->_pre = nullptr;
		delete cur;
	}

	//在 pos 结点前面插入
	void SListInsertFront(Node<T>* pos,int data) {
		Node<T>* node;
		node->_data = data;
		
		node->_next = pos;
		node->_pre = pos->_pre;
		pos->_pre->_next = node;
		pos->_pre = node;
	}
	//在 pos 结点后面插入
	void SListInsertAfter(Node<T>* pos, int data) {
		Node<T>* node;
		node->_data = data;

		node->_pre = pos;
		node->_next = pos->_next;
		pos->_next->_pre = node;
		pos->_next = node;
	}

	//删除 pos 结点
	void SListErase(Node<T>* pos) {
		//只有头结点或只剩下最后一个结点
		if (pos->_next == nullptr) {
			Node<T>* pre = pos->_pre;
			pre->_next = nullptr;
			pos->_pre = nullptr;
			delete pos;
		}else{
			Node<T>* pre = pos->_pre;
			pre->_next = pos->_next;
			pos->_next->_pre = pre;
			pos->_next = pos->_pre = nullptr;
			delete pos;
		}
	}

	//查找结点
	 T SListFind(int data) {
		Node<T>* node = _head->_next;
		while (node != nullptr) {
			if (node->_data == data) {
				return 1;
			}
			node = node->_next;
		}
		return 0;
	}
	//删除v所对应的结点
	void SListEraseV(int data) {
		Node<T>* node = _head->_next;
		while (node != nullptr) {
			if (node->_data == data) {
				Node<T>* next = node->_next;
				SListErase(node);
				node = next;
			}else {
				node = node->_next;
			}
		}
	}

	void Print() {
		Node<T>* node = _head->_next;
		while (node != nullptr) {
			cout << node->_data<<" ";
			node = node->_next;
		}
		cout << endl;
	}
private:
	Node<T>* _head;
};
C C++数据结构（三） —— 双向带头循环链表_c+
2501_90326753的博客
01-18 700
也被称为。
C++——实现双向循环链表（带头结点）
Paranoid_cc的博客
07-06 5126
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 简单的画一个双向循环简易图： 下面就用C++实现一下基本操作 当然也有 C 语言 版的，只是单链表操作 （https://blog.youkuaiyun.com/Paranoid_cc/artic...
数据结构-基本算法-不带头结点的循环链表
05-21
数据结构-基本算法-不带头结点的循环链表(学生时代源码，调试可运行)
C++ 模板双向不循环链表！！
weixin_33831196的博客
07-11 116
CTDChain&lt;T,sort,equal,pointer&gt; * nodeTemp = NULL; ------------------------------------------------------------------------------ using namespace std; //双向不循环链表 //sort 指示是否有序 //equal 指示当出现相...
[C++] LinkList:双向不循环链表的原理和实现(基础)
八宝咸鱼
05-08 512
链表作为计算机中,经典的数据结构.也是程序员的基本功,如果你连链表都不会写,那么最好不要去面试.它是抽象层面的线性表数据结构,在物理上存储,则并不连续. 因为new(malloc)出什么地址,是归计算机分配你只能决定申请多少个,而不是申请什么地址.附双向不循环链表原理图(使用MicrosoftWindows10自带的pint工具绘制)//如果图片看不清,推荐使用imagus插件或者下载原理图原件即便代码部分不熟练,只要记的实现原理,便可以说是掌握链表结构了.链表结构分为多种.{单向不循环链...
c++实现不带头结点的双向非循环链表（代码即注释，超详细版）
weixin_48617416的博客
12-09 1108
c++实现不带头结点的双向非循环链表（代码即注释，超详细版） 直接上代码 #include <iostream> using namespace std; class Node { public: int _data; Node *_pre; Node *_next; Node(int data = 0) : _data(data), _pre(nullptr), _next(nullptr) { // cout << "N
链表--带头结点的非循环双向链表，其中每个结点中多一个freq频度域。每次Locate(L,x)访问过值为x的函数后，freq+1，并使此链表中结点保持按访问频度递减的顺序排列
mu456351zi的博客
04-19 1103
/*带头结点的非循环双向链表，其中每个结点中多一个freq频度域。每次Locate(L,x)访问过值为x的函数后，freq+1，并使此链表中结点保持按访问频度递减的顺序排列， 同时最近访问的结点排在频度相同的结点前面，以便使频繁访问的结点总是靠近表头。试编写符合上述要求的Locate(L,x)运算的算法，返回找到结点的地址，类型为指针型*/ typedef int ElemType; typed...
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
C++实现带头结点的双向循环链表详解
在深入探讨“带头结点的双向循环链表”的知识点之前，我们需要先了解一些基础概念，包括数据结构、链表、以及C++编程语言的相关知识。 首先，“数据结构”是计算机存储、组织数据的方式，它可以帮助我们高效地进行...
C/C++实现循环单链表：带头结点
weixin_44915226的博客
06-19 354
基本功能 初始化循环单链表：带头结点 建立循环单链表：头插法、尾插法 按位查找元素 按值查找元素 按位序插入元素 按位序删除元素 输出循环单链表   代码 循环单链表和循环双向链表有很多相似之处，可以对比学习。 #include <iostream> #include <stdlib.h> using namespace std; typedef int ElemType; typedef struct LNode{ ElemType data; struct
C语言实现双向非循环链表（不带头结点）的清空
乞力马扎罗的雪CYF的博客
02-28 2905
我在之前一篇博客《C语言实现单链表的基本操作》实现了如何清空一个单链表，现在换成了双向的非循环链表，整体思路是一样的。代码上传至：https://github.com/chenyufeng1991/ClearDoubleLinkedList  。核心代码如下：Node *ClearDoubleLinkedList(Node *pNode){ if (pNode == NULL) {
【数据结构】双向非循环链表
ZXC
07-11 457
#include &lt;iostream&gt; using namespace std; struct doubleNode { int data; doubleNode *next; doubleNode *prior; }; typedef doubleNode* LinkList; void init(LinkList *List); bool insert(LinkList...
C语言实现双向非循环链表（带头结点尾结点）的基本操作
乞力马扎罗的雪CYF的博客
03-04 4229
我在之前一篇博客中《C语言实现双向非循环链表（不带头结点）的基本操作》中详细实现了不带头尾节点的双向非循环链表的很多操作。其实同单链表一样，不带头结点的链表很多操作都是比较麻烦的，常常需要对第一个节点做额外的判断，提高了出错的成本。今天我们要来实现带头结点尾结点的双向非循环链表的操作，虽然额外维护了两个节点，但是操作的简便性大大提高了。代码上传至 https://github.com/chenyu
C语言实现双向非循环链表（带头结点尾结点）的节点插入
乞力马扎罗的雪CYF的博客
03-04 3239
对于双向链表，个人推荐使用带头结点尾结点的方式来处理会比较方便。我在《C语言实现双向非循环链表（不带头结点）的节点插入》中详细实现了在不带头结点的情况下的插入。这次我们将会来在使用头结点尾结点的情况下在任意的位置插入元素。代码上传至 https://github.com/chenyufeng1991/InsertNodeDoubleLinkedList_HeadNode 。核心代码如下：//插入一
数据结构 || 带头非循环双链表
Template Code
11-13 1699
带头非循环双链表学习
双向链表
年轻过成了秃顶
12-15 310
题目描述 构建一个双向链表并进行删除和插入操作，按要求输出。 输入 输入： 第一行输入元素个数M 第二行输入M个元素 第三行输入删除位置 第四行输入插入位置和插入元素 第五行输入输出时的起始位置 输出 按要求的起始位置输出链表 样例输入 8 1 2 3 4 5 6 7 8 6 6 6 5 样例输出 5 6 7 8 1 2 3 4 分析： 此题考察链表的多方面知识。我在此题卡了一个早上，真吓人。 ...
C语言实现双向非循环链表（不带头结点）的基本操作
乞力马扎罗的雪CYF的博客
02-27 5539
双向链表也叫双链表，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任何一个节点开始，都可以很方便的访问它的前驱结点和后继节点。别人常常来构造双向循环链表，今天我们特立独行一下，先来尝试构造双向非循环链表。示例代码上传至  https://github.com/chenyufeng1991/DoubleLinkedList 。构造节点：typedef struct
（C++版）链表（四）——实现双向循环链表创建、插入、删除等简单操作
菜鸟学C/C++
05-12 5830
链表（四）实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的温柔香

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值