模拟实现List容器(C++)

最新推荐文章于 2024-07-18 23:31:00 发布
最新推荐文章于 2024-07-18 23:31:00 发布
阅读量151 收藏
点赞数 1
文章标签： c++ 开发语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TL_mood/article/details/129733329
版权

概述

List容器框架

List模拟实现

ListNode节点类

MyList结构

无参构造

List迭代器

完整的MyList类定义

Insert插入数据

Erase删除数据

Push插入数据

Pop删除数据

其他函数

Clear清除数据

析构函数

测试代码MyList.cpp

完整代码MyList.hpp

概述

向博主学习了一下：(84条消息) 【C++】手把手教你写出自己的list类_Ornamrr的博客-CSDN博客

List容器框架

List容器的底层数据结构实际上是带头双向循环链表，框架结构如图：

 

List模拟实现

ListNode节点类

在底层结构中，节点是基本单元，首先我们要定义节点类的模板：

节点模板
template<class T>
class ListNode {
public:
	ListNode<T>* _prev;
	T _val;
	ListNode<T>* _next;

	ListNode(const T& val) : _prev(nullptr), _val(val), _next(nullptr){}
};

MyList结构

定义了节点类，我们要明确List容器的实现逻辑：List容器主要维护一个头节点指针，以访问整个链表：

无参构造

由上面的结构可以对MyList类进行设计和初始化：

///list模板类的实现 维护一个头节点指针，且头仅做连接作用，不存数据
template<class T>
class MyList {
	typedef ListNode<T> Node;
private:
	Node* _head;
public:
	//无参构造
	MyList() {//带头节点的，不实际用
		_head = new Node(0);
		_head->_next = _head;
		_head->_prev = _head;
	}
}

List迭代器

在标准模板库STL中，每种容器都有其独特的迭代器，而List容器的迭代器本质上是一个节点指针，而由于List迭代器相较于vector容器更加复杂，这里对其进行封装，并重载了可能用到的运算符等：

/list迭代器的定义，并不只是简单的类型指针，它的下一位置是_next
template<class T>
struct _list_iterator//参数模板Ref，指针模板Ptr
{
	typedef _list_iterator <T> self;
	typedef ListNode<T> Node;

	Node* _node;

	//构造函数
	_list_iterator(Node* node)
		:_node(node)
	{}
	//重载解引用
	T operator*()
	{
		return _node->_val;
	}
	//重载++和--
	self operator++()
	{
		this->_node = this->_node->_next;
		return *this;
	}
	self operator--()
	{
		this->_node = this->_node->_prev;
		return *this;
	}
	//重载==和！=
	bool operator==(const self& it) const {
		return _node == it._node;
	}

	bool operator!=(const self& it) const {
		return _node != it._node;
	}
};

完整的MyList类定义

///list模板类的实现 维护一个头节点指针，且头仅做连接作用，不存数据
template<class T>
class MyList {
	typedef ListNode<T> Node;
	typedef _list_iterator<T> list_iterator;
private:
	Node* _head;
public:
	//无参构造
	MyList() {//带头节点的，不实际用
		_head = new Node(0);
		_head->_next = _head;
		_head->_prev = _head;
	}
	//拷贝构造
	MyList(MyList<T>& Lt) {
		_head = new Node(0);
		_head->_next = _head;
		_head->_prev = _head;
		Node* cur = Lt._head->_next;
		while (cur != Lt._head) {
			this->push_back(cur->_val);
			cur = cur->_next;
		}
	}
	//重载赋值
	MyList<T>& operator=(MyList<T>& Lt) {
		this->_head = Lt._head;
		return *this;
	}
	
	//成员函数
	void push_back(T val);
	void push_front(T val);
	void pop_back();
	void pop_front();
	void insert(list_iterator pos, T val);
	void erase(list_iterator pos);
	int size();
	bool empty();
	T front();//获取头部元素
	T back();//获取尾部元素
	void clear();//清除除了头节点以外的所有节点

	//迭代器iterator的模拟  头尾的迭代器
	list_iterator begin() {//在前一个位置插入节点insert 头插和尾插
		return _head->_next;//实际的头位置
	}
	list_iterator end() {
		return _head;//尾的下一个位置是头
	}

	//析构函数
	~MyList() {
		this->clear();//释放其他节点
		delete _head;//释放头节点
		_head = NULL;
	}
};

Insert插入数据

这里的插入是pos位置的前一个位置插入节点，头插和尾插也可适用，运行逻辑如图：

 

template<class T>
void MyList<T>::insert(list_iterator pos, T val) {
	Node* prev = pos._node->_prev;
	Node* new_node = new Node(val);
	prev->_next = new_node;
	new_node->_prev = prev;
	new_node->_next = pos._node;
	pos._node->_prev = new_node;
}

Erase删除数据

注意头节点的位置：

template<class T>
void MyList<T>::erase(list_iterator pos) {
	if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	if (pos._node == _head) {//防止删除头部
		Node* prev = pos._node->_prev;
		Node* pprev = prev->_prev;
		pprev->_next = _head;
		_head->_prev = pprev;
		return;
	}
	Node* prev = pos._node->_prev;
	Node* next = pos._node->_next;
	prev->_next = next;
	next->_prev = prev;
	delete pos._node;
}

Push插入数据

可以通过分析实现，也可以利用Insert直接实现：

template<class T>
void MyList<T>::push_back(T val) {
	//Node* tail = _head->_prev;
	//Node* new_node = new Node(val);

	//tail->_next = new_node;
	//new_node->_prev = tail;
	//new_node->_next = _head;
	//_head->_prev = new_node;

	this->insert(this->end(), val);
}

template<class T>
void MyList<T>::push_front(T val) {
	//Node* next = _head->_next;
	//Node* new_node = new Node(val);

	//new_node->_next = next;
	//next->_prev = new_node;
	//new_node->_prev = _head;
	//_head->_next = new_node;
	this->insert(this->begin(), val);
}

Pop删除数据

可以通过分析实现，也可以利用Erase直接实现：

template<class T>
void MyList<T>::pop_back() {
	/*if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	Node* tail = _head->_prev;
	Node* tailprev = tail->_prev;
	delete tail;
	tail = NULL;
	tailprev->_next = _head;
	_head->_prev = tailprev;*/
	this->erase(this->end());
}

template<class T>
void MyList<T>::pop_front() {
	/*if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	Node* front = _head->_next;
	Node* next = front->_next;
	delete front;
	_head->_next = next;
	next->_prev = _head;*/
	this->erase(this->begin());
}

其他函数

template<class T>
int MyList<T>::size() {
	int count = 0;
	Node* cur = _head->_next;
	while (cur != _head) {
		count++;
		cur = cur->_next;
	}
	return count;
}

template<class T>
bool MyList<T>::empty() {
	return this->size() == 0;
}

template<class T>
T MyList<T>::front() {
	return _head->_next->_val;
}

template<class T>
T MyList<T>::back() {
	return _head->_prev->_val;
}

Clear清除数据

清除数据，释放除了头节点以外的所有节点：

template<class T>
void MyList<T>::clear() {
	//释放除了头节点以外的全部节点
	while (_head->_next != _head) {
		this->erase(this->begin());
	}
}

析构函数

释放所有节点：

//析构函数
template<class T>
MyList<T>::~MyList() {
	this->clear();//释放其他节点
	delete _head;//释放头节点
	_head = NULL;
}

测试代码MyList.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"MyList.hpp"

int main() {
	MyList<int> lt;//无参构造
	lt.push_back(1);//尾插
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);

	lt.push_front(6);//头插
	lt.push_front(7);
	lt.push_front(8);

	lt.pop_back();//尾删
	lt.pop_back();

	lt.pop_front();//头删
	lt.pop_front();

	MyList<int> lt1(lt);//拷贝构造

	MyList<int> lt2 = lt;//赋值运算

	lt.insert(lt.begin(), 9);//插入测试
	lt.insert(lt.end(), 10);

	cout << "size = " << lt.size() << endl;
	cout << "front = " << lt.front() << endl;
	cout << "back = " << lt.back() << endl;
	cout << "empty = " << lt.empty() << endl;

	for (_list_iterator<int> it = lt.begin(); it != lt.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
	cout << endl;

	lt.erase(lt.begin());//删除测试
	lt.erase(lt.end());

	lt.clear();//清除测试
	cout << "清理过后: " << endl;
	cout << "empty = " << lt.empty() << endl;


	return 0;
}

完整代码MyList.hpp

#pragma once
#include<iostream>

using namespace std;

//类模板的使用，需要将函数声明和实现写在一个文件中，
//并且文件后缀改为.hpp，在使用时包含头文件。

/C++实现list  带头双向循环链表

节点模板
template<class T>
class ListNode {
public:
	ListNode<T>* _prev;
	T _val;
	ListNode<T>* _next;

	ListNode(const T& val) : _prev(nullptr), _val(val), _next(nullptr){}
};

/list迭代器的定义，并不只是简单的类型指针，它的下一位置是_next
template<class T>
struct _list_iterator//参数模板Ref，指针模板Ptr
{
	typedef _list_iterator <T> self;
	typedef ListNode<T> Node;

	Node* _node;

	//构造函数
	_list_iterator(Node* node)
		:_node(node)
	{}
	//重载解引用
	T operator*()
	{
		return _node->_val;
	}
	//重载++和--
	self operator++()
	{
		this->_node = this->_node->_next;
		return *this;
	}
	self operator--()
	{
		this->_node = this->_node->_prev;
		return *this;
	}
	//重载==和！=
	bool operator==(const self& it) const {
		return _node == it._node;
	}

	bool operator!=(const self& it) const {
		return _node != it._node;
	}
};

///list模板类的实现 维护一个头节点指针，且头仅做连接作用，不存数据
template<class T>
class MyList {
	typedef ListNode<T> Node;
	typedef _list_iterator<T> list_iterator;
private:
	Node* _head;
public:
	//无参构造
	MyList() {//带头节点的，不实际用
		_head = new Node(0);
		_head->_next = _head;
		_head->_prev = _head;
	}
	//拷贝构造
	MyList(MyList<T>& Lt) {
		_head = new Node(0);
		_head->_next = _head;
		_head->_prev = _head;
		Node* cur = Lt._head->_next;
		while (cur != Lt._head) {
			this->push_back(cur->_val);
			cur = cur->_next;
		}
	}
	//重载赋值
	MyList<T>& operator=(MyList<T>& Lt) {
		this->_head = Lt._head;
		return *this;
	}
	
	//成员函数
	void push_back(T val);
	void push_front(T val);
	void pop_back();
	void pop_front();
	void insert(list_iterator pos, T val);
	void erase(list_iterator pos);
	int size();
	bool empty();
	T front();//获取头部元素
	T back();//获取尾部元素
	void clear();//清除除了头节点以外的所有节点

	//迭代器iterator的模拟  头尾的迭代器
	list_iterator begin() {//在前一个位置插入节点insert 头插和尾插
		return _head->_next;//实际的头位置
	}
	list_iterator end() {
		return _head;//尾的下一个位置是头
	}

	//析构函数
	~MyList() {
		this->clear();//释放其他节点
		delete _head;//释放头节点
		_head = NULL;
	}
};

template<class T>
void MyList<T>::push_back(T val) {
	//Node* tail = _head->_prev;
	//Node* new_node = new Node(val);

	//tail->_next = new_node;
	//new_node->_prev = tail;
	//new_node->_next = _head;
	//_head->_prev = new_node;

	this->insert(this->end(), val);
}

template<class T>
void MyList<T>::push_front(T val) {
	//Node* next = _head->_next;
	//Node* new_node = new Node(val);

	//new_node->_next = next;
	//next->_prev = new_node;
	//new_node->_prev = _head;
	//_head->_next = new_node;
	this->insert(this->begin(), val);
}

template<class T>
void MyList<T>::pop_back() {
	/*if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	Node* tail = _head->_prev;
	Node* tailprev = tail->_prev;
	delete tail;
	tail = NULL;
	tailprev->_next = _head;
	_head->_prev = tailprev;*/
	this->erase(this->end());
}

template<class T>
void MyList<T>::pop_front() {
	/*if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	Node* front = _head->_next;
	Node* next = front->_next;
	delete front;
	_head->_next = next;
	next->_prev = _head;*/
	this->erase(this->begin());
}

template<class T>
void MyList<T>::insert(list_iterator pos, T val) {
	Node* prev = pos._node->_prev;
	Node* new_node = new Node(val);
	prev->_next = new_node;
	new_node->_prev = prev;
	new_node->_next = pos._node;
	pos._node->_prev = new_node;
}

template<class T>
void MyList<T>::erase(list_iterator pos) {
	if (_head->_next == _head) {
		cout << "已经删除完毕了，不能再删了！！" << endl;
		return;
	}
	if (pos._node == _head) {//防止删除头部
		Node* prev = pos._node->_prev;
		Node* pprev = prev->_prev;
		pprev->_next = _head;
		_head->_prev = pprev;
		return;
	}
	Node* prev = pos._node->_prev;
	Node* next = pos._node->_next;
	prev->_next = next;
	next->_prev = prev;
	delete pos._node;
}

template<class T>
int MyList<T>::size() {
	int count = 0;
	Node* cur = _head->_next;
	while (cur != _head) {
		count++;
		cur = cur->_next;
	}
	return count;
}

template<class T>
bool MyList<T>::empty() {
	return this->size() == 0;
}

template<class T>
T MyList<T>::front() {
	return _head->_next->_val;
}

template<class T>
T MyList<T>::back() {
	return _head->_prev->_val;
}

template<class T>
void MyList<T>::clear() {
	//释放除了头节点以外的全部节点
	while (_head->_next != _head) {
		this->erase(this->begin());
	}
}

TL_mood
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c模拟c++ stl list
06-18
通过这样的实现，我们可以获得一个功能接近C++`std::list`的C语言版本，虽然在灵活性和效率上可能有所妥协，但它提供了一种在纯C环境中使用类似链表容器的方式。对于那些需要在C环境中实现高效数据结构和算法的...
c++ vector模拟实现代码
12-20
C++中的`vector`是一个非常重要的STL容器，它提供了类似于动态数组的功能，允许在运行时改变其大小。下面我们将详细讨论`vector`的主要特点、内部实现原理以及模拟实现的代码解析。 1. **vector的基本特性** - `...
仿std中的list链表类实现的链表类
danti的专栏
05-18 569
最近在学数据结构，不正确的地方请指出，谢谢！ #pragma once // [5/16/2012 Administrator] // [5/17/2012 Administrator] template class ListClass { public: struct Node{ Object value; Node* head; Node* next; Node(const Obj
list的模拟实现
TANGY的博客
03-11 250
什么是list list是STL标准模板库中的一个容器，它实质上是一个带头双向循环链表。 这样的好处是：插入/删除数据时，不用判断链表是否为空，并且遍历的时候找尾也很容易，只需要用_head-&gt;_prev就能实现。 迭代器 迭代器的作用就是为了让容器的访问像指针一样可以实现++，-- ，解引用，-&gt;，以及重载 !=，==的比较符。 迭代器有两种实现方式： 1...
C++ list容器模拟实现
凡事都是靠练习
08-04 397
讲解list的模拟实现，以及过程中的注意点
C++的标准模板库STL中实现的数据结构之链表std::list的分析与使用
weixin_30808253的博客
07-23 411
摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解，即联系数据结构的理论分析和具体的应用实现（STL），本文是系列总结的第二篇，主要针对线性表中的链表 STL std::list进行分析和总结。 引言 由于前段时间对台大的机器学习基石和技法课程进行了...
C++实验二：多态性应用
ThinkStu的博客
06-09 5956
C++大实验：多态性应用，MyVector、MyList、MyStack、MyQueue重写。
【C++】模拟实现STL容器：list
学了就忘是正常现象
12-06 1617
list的普通迭代器通过类进行封装+运算符重载实现。 list的const通过类模板实现。 operator*返回节点的数据。 operator->返回节点数据的指针。
C++ —— 模拟实现list
weixin_59913110的博客
12-03 824
模拟实现了list容器的常用接口，初步认识模板的用法。
【C++ STL】list容器的简单模拟实现
luoshashou_123的博客
05-23 1097
在vector容器的简单模拟实现中，我们构造了一个简单的vector容器，那相比于其它的容器，vector有哪些优势呢？vector的元素是连续存储的，所以vector的遍历速度非常快。访问下一个元素，不需要利用指针间接寻址，这使得vector元素的线性扫描（find()和copy()）接近最优。vector支持简单且高效的随机访问，这使得vector上的很多算法（如sort()和）非常高效。vector在oj题目里有一个比较常用的用法：二维数组。
【C++】list的模拟实现
qq_62939852的博客
03-11 1296
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
C++【list容器&&模拟实现函数解析】
m0_59292239的博客
03-16 1860
C++【list容器&&模拟实现函数解析】
全国计算机等级考试模拟软件 二级C++
03-26
7. **标准库**：熟悉并能利用STL（Standard Template Library，标准模板库），如容器（vector、list、set等）、算法和迭代器等。 8. **输入/输出**：掌握iostream库中的cin和cout用于标准输入输出，以及文件流的使用...
操作系统缓冲池模拟和实现（C++版）
12-26
在项目中，开发者可能会使用STL容器（如vector或list）来存储缓冲区对象，利用C++的智能指针（如shared_ptr）来管理内存，同时结合C++11及更高版本提供的线程库来实现线程安全的缓冲池操作。 通过这个C++版的操作...
cPP.rar_c++ 容器使用_容器
09-19
首先，C++中的容器分为几种主要类型：顺序容器（如vector、deque和list）、关联容器（如set、multiset、map和multimap）以及特殊容器（如stack、queue和priority_queue）。每个容器都有其特定的用途和性能特点。 1....
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1089
c++ primer plus 第16章string 类和标准模板库,string 类输入。
C++ 继承篇
最新发布
2301_79201049的博客
07-18 430
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
c++ 生成随机字符串
m0_56306892的博客
07-15 213
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 149
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ STL容器详解：通用数据结构与算法模板
总结来说，STL容器是C++编程中不可或缺的一部分，它提供了丰富的数据结构和算法，利用模板机制实现了高度的类型灵活性，极大地提高了代码的复用性和性能。掌握STL是成为一名高级C++程序员的关键技能之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值