基于面向对象，C++实现双链表

已于 2024-01-18 21:45:03 修改
阅读量532 收藏 7
点赞数 10
分类专栏： C++ 文章标签： c++ 开发语言 数据结构 链表 算法
于 2024-01-14 22:43:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44961737/article/details/135588312
版权

双链表同单链表类似，由一个值和两个指针组成
在这里插入图片描述

Node.h节点头文件

#pragma once
class Node
{
public:
	int value;
	Node* prev;
	Node* next;

	Node(int value);
	~Node();
};

Node.cpp节点源文件

#include "Node.h"

Node::Node(int value)
{
	this->value = value;
	prev = nullptr;
	next = nullptr;
}

Node::~Node()
{
}

DoubleLinkList.h双链表头文件

#pragma once
#include "Node.h"
class DoubleLinkList
{public:
	Node* head;
	Node* tail;
	int length;

	DoubleLinkList(int val);//有参构造
	void PrintDoubleLinkList();//打印双链表
	void getLength();//获取双链表长度

	void append(int val);//尾部插入元素
	void prepend(int val);//头部插入元素
	void insert(int index, int val);//任意位置插入元素

	Node* removeLast();//删除最后一个元素
	Node* removeFirst();//删除第一个元素
	Node* remove(int index);//删除任意位置元素

	Node* get(int index);//获取元素
	bool change(int index, int val);//改变元素
	int search(int val);//查找元素
};

DoubleLinkList.cpp节点源文件

#include "DoubleLinkList.h"
#include<iostream>
using namespace std;


DoubleLinkList::DoubleLinkList(int val)
{
	Node* newNode = new Node(val);
	head = newNode;
	tail = newNode;
	length = 1;
}

//打印链表
void DoubleLinkList::PrintDoubleLinkList()
{
	Node* temp = head;
	while (temp!=nullptr) {
		cout << temp->value << " ";
		temp = temp->next;
	}
	cout << endl;
}
//获取双链表长度
void DoubleLinkList::getLength()
{
	cout << "双链表长度为：" << length << endl;
}

//尾部插入
void DoubleLinkList::append(int val)
{
	Node* newNode = new Node(val);
	if (length == 0) {
		head = newNode;
		tail = newNode;
	}
	else {
		tail->next = newNode;
		newNode->prev = tail;
		tail = newNode;
	}
	length++;
}

//头部插入
void DoubleLinkList::prepend(int val)
{
	Node* newNode = new Node(val);
	if (length == 0) {
		head = newNode;
		tail = newNode;
	}
	else {
		newNode->next = head;
		head->prev = newNode;
		head = newNode;
	}
	length++;
}

//任意位置插入
void DoubleLinkList::insert(int index, int val)
{
	if (index<0 || index>length) {
		cout << "error";
	}
	else if (index == 0) {
		prepend(val);
	}
	else if(index == length){
		append(val);
	}
	else {
		Node* p1 = head;
		for (int i = 0; i < index - 1; i++) {
			p1 = p1->next;
		}
		Node* p2 = p1->next;
		Node* newNode = new Node(val);
		newNode->prev = p1;
		newNode->next = p2;
		p1->next = newNode;
		p2->prev = newNode;
		length++;
	}
}

//删除尾部
Node* DoubleLinkList::removeLast()
{
	if (length == 0) {
		return nullptr;
	}
	Node* temp = tail;
	if (length == 1) {
		head = nullptr;
		tail = nullptr;
	}
	else {
		tail = tail->prev;
		tail->next = nullptr;
		temp->prev = nullptr;
	}
	length--;
	return temp;
}

//删除头部
Node* DoubleLinkList::removeFirst()
{
	if (length == 0) {
		return nullptr;
	}
	Node* temp = head;
	if (length == 1) {
		head = nullptr;
		tail = nullptr;
	}
	else {
		head = head->next;
		head->prev = nullptr;
		temp->next = nullptr;
	}
	length--;
	return temp;
}

//删除任意位置
Node* DoubleLinkList::remove(int index)
{
	if (index<0 || index>length) {
		return nullptr;
	}
	if (index == 0) {
		return removeFirst();
	}
	if (index == length - 1) {
		return removeLast();
	}
	Node* temp = head;
	for (int i = 0; i < index; i++) {
		temp = temp->next;
	}
	temp->next->prev = temp->prev;
	temp->prev->next = temp->next;
	temp->next = nullptr;
	temp->prev = nullptr;
	length--;
	return temp;
}

//获取元素
Node* DoubleLinkList::get(int index)
{
	
	if (index<0 || index>length) {
		return nullptr;
	}
	Node* temp = head;
	if (index < length / 2) {
		for (int i = 0; i < index; i++) {
			temp = temp->next;
		}
	}
	else {
		temp = tail;
		for (int i = length - 1; i > index; i--) {
			temp = temp->prev;
		}
	}
	return temp;
}

//改变元素
bool DoubleLinkList::change(int index, int val)
{
	Node* temp = get(index);
	if (temp) {
		temp -> value = val;
		return true;
	}
	return false;
}

//查找元素
int DoubleLinkList::search(int val)
{
	int index = 0;
	Node* temp = head;
	while (temp->value != val) {
		index++;
		temp = temp->next;
		if (temp == nullptr) {
			cout << "未找到！" << endl;
			return -1;
		}
	}
	cout << "找到了！元素索引为：";
	return index;
}

插入元素

1. 头部插入

1.新节点的next指向head节点
2.head节点的prev指向新节点
3.head移动至新节点
具体如下图所示：

在这里插入图片描述

//头部插入
void DoubleLinkList::prepend(int val)
{
	Node* newNode = new Node(val);
	if (length == 0) {
		head = newNode;
		tail = newNode;
	}
	else {
		newNode->next = head;
		head->prev = newNode;
		head = newNode;
	}
	length++;
}

2. 尾部插入

1.尾节点tail的next指向新节点
2.新节点的prev指向尾节点tail
3.tail节点移动到新节点

在这里插入图片描述

//尾部插入
void DoubleLinkList::append(int val)
{
	Node* newNode = new Node(val);
	if (length == 0) {
		head = newNode;
		tail = newNode;
	}
	else {
		tail->next = newNode;
		newNode->prev = tail;
		tail = newNode;
	}
	length++;
}

3. 任意位置插入

1.创建新节点p1指向头结点head，然后移动至插入节点前一个节点，并创建新节点p2指向p1的next节点
2.新节点的prev指向p1
3.新节点的next指向p2
4.p1节点的next指向新节点
5.p2节点的prev指向新节点

在这里插入图片描述

//任意位置插入
void DoubleLinkList::insert(int index, int val)
{
	if (index<0 || index>length) {
		cout << "error";
	}
	else if (index == 0) {
		prepend(val);
	}
	else if(index == length){
		append(val);
	}
	else {
		Node* p1 = head;
		for (int i = 0; i < index - 1; i++) {
			p1 = p1->next;
		}
		Node* p2 = p1->next;
		Node* newNode = new Node(val);
		newNode->prev = p1;
		newNode->next = p2;
		p1->next = newNode;
		p2->prev = newNode;
		length++;
	}
}

删除元素

1. 尾部删除

1.新建一个节点temp指向尾节点tail
2.尾节点tail移动至tail的prev节点
3.尾节点tail的next指向空
4.temp的prev指针指向空

在这里插入图片描述

//删除尾部
Node* DoubleLinkList::removeLast()
{
	if (length == 0) {
		return nullptr;
	}
	Node* temp = tail;
	if (length == 1) {
		head = nullptr;
		tail = nullptr;
	}
	else {
		tail = tail->prev;
		tail->next = nullptr;
		temp->prev = nullptr;
	}
	length--;
	return temp;
}

2. 头部删除

1.新建一个节点temp指向头结点head
2.head节点移动到head的next指针指向的节点
3.head的prev指针指向nullptr
4.temp节点的next指针指向nullptr

在这里插入图片描述

//删除头部
Node* DoubleLinkList::removeFirst()
{
	if (length == 0) {
		return nullptr;
	}
	Node* temp = head;
	if (length == 1) {
		head = nullptr;
		tail = nullptr;
	}
	else {
		head = head->next;
		head->prev = nullptr;
		temp->next = nullptr;
	}
	length--;
	return temp;
}

3. 任意位置删除

1.新建一个节点temp指向头结点head
2.temp移动到要删除的节点处
3.temp的next节点的prev指针指向temp的prev节点
4.temp的prev节点的next指针指向temp的next节点
5.temp的next节点指向nullptr
6.temp的prev节点指向nullptr

在这里插入图片描述

//删除任意位置
Node* DoubleLinkList::remove(int index)
{
	if (index<0 || index>length) {
		return nullptr;
	}
	if (index == 0) {
		return removeFirst();
	}
	if (index == length - 1) {
		return removeLast();
	}
	Node* temp = head;
	for (int i = 0; i < index; i++) {
		temp = temp->next;
	}
	temp->next->prev = temp->prev;
	temp->prev->next = temp->next;
	temp->next = nullptr;
	temp->prev = nullptr;
	length--;
	return temp;
}

获取元素

1.比较索引和链表长度的大小
2.若索引比length小，则在链表的前一半向后找
3.若索引比length大，则在链表的后一半向前找

在这里插入图片描述

//获取元素
Node* DoubleLinkList::get(int index)
{
	
	if (index<0 || index>length) {
		return nullptr;
	}
	Node* temp = head;
	if (index < length / 2) {
		for (int i = 0; i < index; i++) {
			temp = temp->next;
		}
	}
	else {
		temp = tail;
		for (int i = length - 1; i > index; i--) {
			temp = temp->prev;
		}
	}
	return temp;
}

改变元素

1.获取节点
2.将节点的值改为需要的值即可

在这里插入图片描述

//改变元素
bool DoubleLinkList::change(int index, int val)
{
	Node* temp = get(index);
	if (temp) {
		temp -> value = val;
		return true;
	}
	return false;
}

查找元素

1.新建一个节点temp指向头结点head
2.不断向后移动temp并判断temp是否威空
3.最终返回索引

//查找元素
int DoubleLinkList::search(int val)
{
	int index = 0;
	Node* temp = head;
	while (temp->value != val) {
		index++;
		temp = temp->next;
		if (temp == nullptr) {
			cout << "未找到！" << endl;
			return -1;
		}
	}
	cout << "找到了！元素索引为：";
	return index;
}

测试：新建一个main文件进行测试

#include<iostream>
#include"Node.h"
#include"DoubleLinkList.h"

using namespace std;

void test01() {
	DoubleLinkList* myList = new DoubleLinkList(1);
	myList->append(3);
	myList->append(5);
	myList->append(7);
	myList->append(9);
	myList->PrintDoubleLinkList();
	myList->getLength();
}

void test02() {
	DoubleLinkList* myList1 = new DoubleLinkList(1);
	myList1->append(3);
	myList1->append(5);
	myList1->append(7);
	myList1->append(9);
	//myList1->insert(5, 4);
	//myList1->removeLast();
	//myList1->remove(2);
	//cout<<myList1->get(4)->value<<endl;
	//myList1->change(2, 4);
	cout<<myList1->search(5)<<endl;
	myList1->PrintDoubleLinkList();
	myList1->getLength();
}

int main() {
	//test01();
	test02();
}

测试结果如下：
在这里插入图片描述

ＭＡＤＡＯ
关注
专栏目录
单链表的C/C++实现方法——面向对象思想
白衣苍狗
03-09 1033
单链表的C/C++实现方法——面向对象思想 参考视频：https://www.bilibili.com/video/av73844865?from=search&seid=14703049787269972364 本文是学习了上面的视频总结而成。C代码参考实现，C++代码自主实现。 20200309 seafire 一个比喻 链表在内存中并不一定连续。他由多个节点组成，节点内...
C++双向循环链表实现约瑟夫环
猫的薛定谔
12-20 2489
C++双向链表实现约瑟夫环 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面...
基于面向对象编程，C++实现单链表
qq_44961737的博客
01-12 1068
基于面向对象的方法超详细介绍单链表的常见API
数据结构（基于C++模板）--单链表
weixin_39701261的博客
04-04 217
也有好久没有更新博文啦，最近在弄一个小东西，之后再给大家展示，接下来先给大家一些数据结构的C++实现干活，记得屯好粮哈！ 之前一直用的数据结构是C实现，最近发现C++用起来更有feel，也推荐一下。 三话不说啦，接码 ...%*&￥#*&（^&$#@^%*()$#&@*(^%& //singleLink.h #ifndef __SINGL...
单向链表的操作--C++实现
G1842965496的博客
07-09 189
单线链表的操作（C++实现） #include <iostream> #include <cstdlib> using namespace std; class Node { public: int value; Node *next; }; class Linklist { public: Linklist(); //创建一个单链表 ~Linklist();
C++面向对象实现一个模板类链表
qq_29185043的博客
06-03 2136
题目：1.    请创建一个数据类型为T的链表类模板List，实现以下成员函数：1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(constList&lt;T&gt;&amp; list)，根据一个给定的链表构造当前链表（10分） 3） 析构函数~List()，释放链表中的所有节点（10分） 4） Push_back(T e)函数，往链表最末尾插入一...
【C++数据结构实验】基于双链表实现双端队列，Deque的面向对象链表实现。
Amston的博客
04-24 2101
双端队列是限定插入和删除操作在表的两端进行的线性表。这两端分别称做端点1和端点2。也可像栈一样，可以用一个铁道转轨网络来比喻双端队列。在实际使用中，还可以有输出受限的双端队列（即一个端点允许插入和删除，另一个端点只允许插入的双端队列）和输入受限的双端队列（即一个端点允许插入和删除，另一个端点只允许删除的双端队列）。而如果限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻的栈了。
双链表学生管理系统（面向对象）
02-13
总的来说，这个双链表学生管理系统利用面向对象的特性，结合双链表的数据结构，提供了一种有效管理和操作学生信息的方式。通过类的设计，我们可以实现数据的封装和代码的模块化，通过继承和多态，我们可以构建灵活且...
基于C++(QT)链表实现过程化（数据结构）【100011836】
04-11
功能分为三个板块，分别是单链表、循环链表、双向链表的建立、插入、删除等基本操作的过程。 单链表：●查看单链表定义，相应算法...上述所有功能采用面向对象的方法通过C++语言程序结合QT框架实现，后面会详细介绍。
new_infor.rar_双向链表_电话簿类C++
09-23
为了确保类的高效性和可维护性，应遵循良好的面向对象编程原则，如封装、继承和多态。类的设计应尽可能简洁，将数据和操作数据的方法封装在一起，以提高代码的模块化和可读性。此外，可以考虑实现一些额外的功能，如...
C++面向对象方式建立链表以及相关操作
weixin_55037029的博客
07-16 715
最近在看b站上一个视频，学习数据结构，了解链表后发现所有的视频都不是面向对象方式，然后就好奇，面向对象应该如何实现链表，是否会更方便。 1.运行结果 1）首先插入6个元素 2）删除结点 3）打印删除后的链表 4）反转链表2.源码 #include<iostream> using namespace std; struct Node { int data; Node* next; }; class list { public: Node* head; //头节点地址...
C++ 链表面向对象实现
wwxy1995的博客
10-15 2647
C语言的操作集 下面是C++实现 Node类，其中*Node和数据域直接放在public里，为了可以直接访问 Node.h #pragma once class Node { public: int data; Node *next; void printNode(); }; Node.cpp #include "stdafx.h" #include "Node.h"...
面向对象c++数据结构--基本数据结构之链表（连载中……）（凌风）
dragon_horse的专栏
09-17 1432
第3章 链表 使用向量带来的问题之一便是：在每次修改向量大小的时候，都需要分配和释放存储空间，从而产生内存碎片。如果减少重新改变向量大小的次数，先分配元素块，然后再删除元素块，那么向量则会占用超出需要的更多空间。 如果希望数据结构不多不少仅仅占用正好满足需要需要的那么多存储空间，并且不希望直接访问数据结构中的对象，那么可以使用链表。链表表示以某种已知的顺序将对象串接在一起。访问从链
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
最新发布
zhaoylzy的博客
11-16 895
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 527
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
C++ 中的string类
2201_75357870的博客
11-15 790
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
C++——智能指针
Wangx_wang的博客
11-12 972
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 1022
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
C++初阶——list
qq_55890817的博客
11-12 953
list是一个可以在序列的任意位置进行插入和删除的容器，并且可以进行双向迭代。list的底层是一个双向链表，双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。通过将每个元素与前一个元素的链接和后一个元素的链接关联起来，内部保持了顺序。
C++数据结构实践：双向循环链表实现贪吃蛇游戏
资源摘要信息:"基于C++数据结构双向循环链表实现的贪吃蛇【***】" 知识点详细说明： 1. C++编程语言应用：本项目主要使用C++语言进行编程。C++是一种广泛使用的高级编程语言，它支持面向对象、泛型以及过程化编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值