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

最新推荐文章于 2024-07-22 15:41:09 发布
最新推荐文章于 2024-07-22 15:41:09 发布
阅读量152 收藏
点赞数 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 570
最近在学数据结构，不正确的地方请指出，谢谢！ #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 251
什么是list list是STL标准模板库中的一个容器，它实质上是一个带头双向循环链表。 这样的好处是：插入/删除数据时，不用判断链表是否为空，并且遍历的时候找尾也很容易，只需要用_head-&gt;_prev就能实现。 迭代器 迭代器的作用就是为了让容器的访问像指针一样可以实现++，-- ，解引用，-&gt;，以及重载 !=，==的比较符。 迭代器有两种实现方式： 1...
C++ list容器模拟实现
凡事都是靠练习
08-04 399
讲解list的模拟实现，以及过程中的注意点
C++的标准模板库STL中实现的数据结构之链表std::list的分析与使用
weixin_30808253的博客
07-23 412
摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解，即联系数据结构的理论分析和具体的应用实现（STL），本文是系列总结的第二篇，主要针对线性表中的链表 STL std::list进行分析和总结。 引言 由于前段时间对台大的机器学习基石和技法课程进行了...
C++实验二：多态性应用
ThinkStu的博客
06-09 5959
C++大实验：多态性应用，MyVector、MyList、MyStack、MyQueue重写。
【C++】模拟实现STL容器：list
学了就忘是正常现象
12-06 1619
list的普通迭代器通过类进行封装+运算符重载实现。 list的const通过类模板实现。 operator*返回节点的数据。 operator->返回节点数据的指针。
C++ —— 模拟实现list
weixin_59913110的博客
12-03 826
模拟实现了list容器的常用接口，初步认识模板的用法。
【C++ STL】list容器的简单模拟实现
luoshashou_123的博客
05-23 1098
在vector容器的简单模拟实现中，我们构造了一个简单的vector容器，那相比于其它的容器，vector有哪些优势呢？vector的元素是连续存储的，所以vector的遍历速度非常快。访问下一个元素，不需要利用指针间接寻址，这使得vector元素的线性扫描（find()和copy()）接近最优。vector支持简单且高效的随机访问，这使得vector上的很多算法（如sort()和）非常高效。vector在oj题目里有一个比较常用的用法：二维数组。
【C++】list的模拟实现
qq_62939852的博客
03-11 1299
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
C++【list容器&&模拟实现函数解析】
m0_59292239的博客
03-16 1862
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++ 继承篇
2301_79201049的博客
07-18 675
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 175
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 368
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C语言动态内存管理
最新发布
m0_62183318的博客
07-22 675
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
C++编程：类模板实现Animal及Vector模拟STL向量
"C++程序设计，涉及到类模板和自定义容器类的实现，以及继承和多态的应用。" 在C++编程中，类模板是一种强大的工具，它允许程序员创建可应用于不同数据类型的通用类。类模板使得我们可以写出更加灵活且可重用的代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值