模拟实现c++中的list模版

最新推荐文章于 2024-10-09 10:07:13 发布
最新推荐文章于 2024-10-09 10:07:13 发布
阅读量934 收藏 32
点赞数 30
分类专栏： c++的不归之路 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82648291/article/details/140796776
版权

                ☺☺☺☺☺☺☺☺☺☺  点击 进入杀马特的主页☺☺​​​​​​​☺​​​​​​​☺​​​​​​​☺​​​​​​​☺​​​​​​​☺​​​​​​​☺​​​​​​​☺​​​​​​​☺

目录

一·list简述：

二·库内常用接口函数使用：

1·reverse():

 2.sort():

 3.merge():

 4.unique():

5.splice():

三·list的模拟实现相关函数接口：

1.创建头结点和无参构造：

2·有参构造： 

3·拷贝构造：

4·赋值重载的现代版本实现：

5.析构函数：

6·list的迭代器类模版内接口函数的实现：

7.insert的接口函数的实现：

8.push_back和push_front的实现：

9·erase的接口函数的实现：

10·pop_front和pop_back的实现：

11·size和empty的实现： 

 12·front和back的实现：

13·不同容器利用迭代器打印数据：

 

一·list简述：

即相当于一个放入任意类型的一个容器，底层就是链表。即是与vector的区别。

二·库内常用接口函数使用：

这里简单介绍一下除了下面要实现的接口函数还有些其他接口函数：

1·reverse():

对于以前的vector和string，它们用的是算法库里的，故括号里还要传迭代器区间，而list库自己实现了，可以不传参：

list<int> lt;
lt.emplace_back(1);
lt.emplace_back(2);
lt.emplace_back(3);
lt.emplace_back(4);

lt.reverse();
list<int>::iterator it = lt.begin();
it = lt.begin();
while (it != lt.end()) {
	cout << *it << " ";
	it++;
}

 2.sort():

对于list库里的sort（）是默认升序。

list<int> ltt;
ltt.emplace_back(5);
ltt.emplace_back(3);
ltt.emplace_back(7);
ltt.emplace_back(10);
ltt.sort();
list<int>::iterator itt = ltt.begin();
while (itt != ltt.end()) {
	cout << *itt << " ";
	itt++;
}

当然也可以也可以这样完成升降序：

 

 

同理，这里其实也可以不创建对象，直接匿名对象也可以。

 3.merge():

即把两个list对象按升序拼接起来（前提是两个对象都是有序的，不是的话要提前给它sort一下），最后拼到前者对象，后者对象清空，如：

list<int> lt;
lt.emplace_back(1);
lt.emplace_back(2);
lt.emplace_back(3);
lt.emplace_back(4);
list<int> ltt;
ltt.emplace_back(5);
ltt.emplace_back(3);
ltt.emplace_back(7);
ltt.emplace_back(10);
ltt.sort();
list<int>::iterator it = lt.begin();
lt.merge(ltt);
it = lt.begin();
while (it != lt.end()) {
	cout << *it << " ";
	it++;
}
cout << endl;

 4.unique():

去重复操作，但是要求list对象要有序：

///去重操作：
list<int> lt;
lt.emplace_back(1);
lt.emplace_back(1);
lt.emplace_back(1);
lt.emplace_back(2);
lt.unique();
list<int>::iterator it = lt.begin();
it = lt.begin();
while (it != lt.end()) {
	cout << *it << "";
	it++;
}
cout << endl;

5·remove():

删除链表中值为val的节点：

//删除指定元素，只删除找到一个即可：
list<int> lt;
lt.emplace_back(5);
lt.emplace_back(2);
lt.emplace_back(4);
lt.emplace_back(2);
lt.remove(2);
list<int>::iterator it = lt.begin();
it = lt.begin();
while (it != lt.end()) {
	cout << *it << "";
	it++;
}

5.splice():

本意是粘连的意思，可以给某个位置前面粘连一个对象的链表也可以给某个位置前粘连任意一个对象的迭代器区间：

一个对象给另一个对象粘：

list<int> lt;
lt.emplace_back(5);
lt.emplace_back(2);
lt.emplace_back(4);
lt.emplace_back(2);
list<int> ltt;
ltt.emplace_back(5);
ltt.emplace_back(3);
ltt.emplace_back(7);
ltt.emplace_back(10);
list<int>::iterator it = lt.begin();
lt.splice(++lt.begin(), ltt);
it = lt.begin();
while (it != lt.end()) {
	cout << *it << " ";
	it++;
}

给pos位置前粘一个迭代器区间：

list<int> lt;
lt.emplace_back(5);
lt.emplace_back(2);
lt.emplace_back(4);
lt.emplace_back(2);
list<int> ltt;
ltt.emplace_back(5);
ltt.emplace_back(3);
ltt.emplace_back(7);
ltt.emplace_back(10);
list<int>::iterator it = lt.begin();
lt.splice(it, lt, ++lt.begin(), lt.end());
it = lt.begin();//这里会把242转移粘在5的前面，故要重新给begin赋值
while (it != lt.end()) {
		cout << *it << " ";
		it++;
	}

 

粘连别人的迭代器区间：

list<int> lt;
lt.emplace_back(5);
lt.emplace_back(2);
lt.emplace_back(4);
lt.emplace_back(2);
list<int> ltt;
ltt.emplace_back(5);
ltt.emplace_back(3);
ltt.emplace_back(7);
ltt.emplace_back(10);
list<int>::iterator it = lt.begin();
lt.splice(++lt.begin(), ltt, ++ltt.begin(), ltt.end());
it = lt.begin();
while (it != lt.end()) {
		cout << *it << " ";
		it++;
	}

 

 

三·list的模拟实现相关函数接口：

框架构造：list是吧每个节点连接起来，故首先把节点封装成一个类，接着由于迭代器相当于节点指针，即双向迭代器，只能是++或者--无-，+即还要对迭代器去遍历链表，可以把迭代器封装也成一个类。如：

节点类：

namespace li {
	template<class T>
	struct list_node {
		list_node* _pre;
		list_node* _next;
		T _val;
		list_node(const T _val = T())
			:_val(_val)
			, _pre(nullptr)
			, _next(nullptr) { }



	};

迭代器 类：

template<class T,class ref,class ptr >
	struct list_iterator {
		typedef list_node<T> Node;
		Node* _node;

		list_iterator( Node* node)
			:_node(node)
		{}
};

它们没有资源产生和释放，故只用写所需要的构造函数即可。 

这里的template<class T,class ref,class ptr >是为了少写一次const迭代器的类，而多加了对原来的类的模版参数可以实例化出const和普通的迭代器类。

list框架：

template<class T>
	class list {
	public:
		typedef list_node<T> Node;
		typedef list_iterator<T,  T&,  T*> iterator;
		typedef  list_iterator<T,const T&,const T*> const_iterator;
private:


		Node* _head;
		int _size;

	};

1.创建头结点和无参构造：

void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_pre = _head;
			_size = 0;
		}

		list() {
			empty_init();

		}

由于后面等有参构造list的时候也是需要构造出头结点，故可以把它封装成一个empty_init函数。 

2·有参构造： 

list( initializer_list<T> m)//这个模版化出的m对象可以想象成一个数组
		{
			empty_init();
			for (auto& e : m)
			{
				push_back(e);
			}
		}
initializer_list<int> il = { 10, 20, 30 };
	li::list<int> llt(il);
	//拷贝构造：
	li::list<int>lt1({ 1,22,223 });//先是隐式类型转换生成的临时对象再拷贝构造给lt1
  //隐式类型转换：
	const li::list<int>&lt2={ 1,22,223 };//直接隐式类型转换生成临时对象，由于是给临时对象引用（起别名）故临时对象只能读不能写，故用const

这里可以用 initializer_list这个模版来进行{}的初始化。

3·拷贝构造：

list(const list<T>& lt)
		{
			empty_init();//创建链表的头结点

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

4·赋值重载的现代版本实现：


		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		list<T>& operator=(list<T> lt)//不是引用传参故不会改变lt；
		{
			swap(lt);
			return *this;
		}

5.析构函数：

void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}//利用迭代器遍历链表删除各个节点
		~list() {
			clear();
			delete _head;
			_head = nullptr;
		}

6·list的迭代器类模版内接口函数的实现：

ref operator*() {

			return _node->_val;
		}
		ptr operator->() {
			return &(_node->_val) ;
		}
		list_iterator<T,ref, ptr> &operator++(int) {
			list_iterator<T,ref,ptr> tmp = *this;
			++*this;
			return tmp;
		}
		list_iterator<T,ref, ptr>&operator--(int) {
			list_iterator<T,ref,ptr> tmp = *this;
			--*this;
			return tmp;
		}
		list_iterator<T,ref, ptr>& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		list_iterator<T,ref, ptr>& operator--()
		{
			_node = _node->_pre;
			return *this;
		}

		bool operator!=(const  list_iterator<T,ref,ptr>& s) const
		{
			return _node != s._node;
		}

		bool operator==(const  list_iterator<T,ref,ptr>& s) const
		{
			return _node == s._node;
		}

这里需要说的也就是里面对->的重载运算符函数的实现，这样返回节点内数据的地址作用在哪？

其实是为了：如果这里面的val放的自定义类型如：

 

 

struct AA {

	int a1 = 1;
	int a2 = 2;
};

这时候这个操作就可以直接访问到val里的a1，a2，而不用再有通过AA的对象再去访问a1和a2。

li::list<AA> at;
	at.push_back(AA());
	at.push_back(AA());
	at.push_back(AA());
	at.push_back(AA());
	li::list<AA>::iterator ait = at.begin();

	 
	cout << (ait-> a1 )<<" ";//如果是自定义类型则迭代器（也就是节点的指针）可以直接访问到此自定义类型的变量。
	//如果没有这个重载：
	cout << ((ait._node)->_val.a1 )<< " ";
	//重载后把两个->省略成一个
	cout << (ait.operator->()->a1) << " ";

7·begin（）和end（）的实现：

这里是list直接访问的，故放在list类模版的函数里。

iterator begin() {
			return _head->_next;//隐式类型转换，直接传递对应类的构造参数
		}
		iterator end() {
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const//对应的迭代器实例化出的普通和const类型
		{
			return _head;
		}

7.insert的接口函数的实现：

iterator  insert(iterator pos, const T& x) {
			//在pos和pos前的位置插入数据，故先保存这两个位置。以防后面找不到，然后在连接指针
			Node* pre = pos._node->_pre ;
			Node* cur = pos._node;
			Node* pnode = new Node(x);
			pnode->_next = cur;
			cur->_pre = pnode;
			pre->_next = pnode;
			pnode->_pre = pre;
			_size++;
			return pnode;
		}

这里其实和vector的迭代器不一样，这里插入不会导致迭代器失效，因为它所指向的对象并没有改变，而只是在它前面插入新节点。 

8.push_back和push_front的实现：

void push_back(const T& x) {
			insert(end(), x);

		}

		void push_front(const T& x) {
			insert(begin(), x);
		}

9·erase的接口函数的实现：

这里如果删除了就会导致迭代器失效，故要利用返回值接收再次使用。

iterator erase(iterator pos) {
			assert(pos != end());
			Node* pre = pos._node->_pre;
			Node* next = pos._node->_next;
			delete pos._node ;
			pre->_next = next;
			next->_pre = pre;
			_size--;
			return next;

		}

10·pop_front和pop_back的实现：

void pop_front() {
			erase(begin());
		}
		void pop_back() {
			erase(--end());

		}

11·size和empty的实现： 

size_t size() const
		{
			return _size;
		}

		bool empty() const
		{
			return _size == 0;
		}

 12·front和back的实现：

T& front() {
			return begin()._node->_val;
		}
		const T& front()const {
			return begin()._node->_val;
		}
		T& back() {
			return (--end())._node->_val;
		}
		const T& back()const {
			return --end()._node->_val;
		}//分别是拿到val可修改与不可修改

13·不同容器利用迭代器打印数据：

//不同容器的打印
template<class Container>
void  con_print(const Container & con) {
	typename Container::const_iterator it = con.begin();//告诉未实例化的模版是类型
	//auto it = con.begin();
	while (it != con.end())
	{

		cout << *it << " ";
		++it;
	}
	cout << endl;

	
}

14.list实现代码汇总：

#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
namespace li {
	template<class T>
	struct list_node {
		list_node* _pre;
		list_node* _next;
		T _val;
		list_node(const T _val = T())
			:_val(_val)
			, _pre(nullptr)
			, _next(nullptr) { }



	};
	template<class T,class ref,class ptr >
	struct list_iterator {
		typedef list_node<T> Node;
		Node* _node;

		list_iterator( Node* node)
			:_node(node)
		{}
	
	
		ref operator*() {

			return _node->_val;
		}
		ptr operator->() {
			return &(_node->_val) ;
		}
		list_iterator<T,ref, ptr> &operator++(int) {
			list_iterator<T,ref,ptr> tmp = *this;
			++*this;
			return tmp;
		}
		list_iterator<T,ref, ptr>&operator--(int) {
			list_iterator<T,ref,ptr> tmp = *this;
			--*this;
			return tmp;
		}
		list_iterator<T,ref, ptr>& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		list_iterator<T,ref, ptr>& operator--()
		{
			_node = _node->_pre;
			return *this;
		}

		bool operator!=(const  list_iterator<T,ref,ptr>& s) const
		{
			return _node != s._node;
		}

		bool operator==(const  list_iterator<T,ref,ptr>& s) const
		{
			return _node == s._node;
		}

	};

	template<class T>
	class list {
	public:
		typedef list_node<T> Node;
		typedef list_iterator<T,  T&,  T*> iterator;
		typedef  list_iterator<T,const T&,const T*> const_iterator;

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_pre = _head;
			_size = 0;
		}

		list() {
			empty_init();

		}
		list( initializer_list<T> m)//这个模版化出的m对象可以想象成一个数组
		{
			empty_init();
			for (auto& e : m)
			{
				push_back(e);
			}
		}

		list(const list<T>& lt)
		{
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		list<T>& operator=(list<T> lt)//不是引用传参故不会改变lt：
		{
			swap(lt);
			return *this;
		}
		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~list() {
			clear();
			delete _head;
			_head = nullptr;
		}
		iterator begin() {
			return _head->_next;//隐式类型转换，直接传递对应类的构造参数
		}
		iterator end() {
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}

		const_iterator end() const
		{
			return _head;
		}
		
		iterator  insert(iterator pos, const T& x) {
			//在pos和pos前的位置插入数据，故先保存这两个位置。以防后面找不到，然后在连接指针
			Node* pre = pos._node->_pre ;
			Node* cur = pos._node;
			Node* pnode = new Node(x);
			pnode->_next = cur;
			cur->_pre = pnode;
			pre->_next = pnode;
			pnode->_pre = pre;
			_size++;
			return pnode;
		}
		void push_back(const T& x) {
			insert(end(), x);

		}

		void push_front(const T& x) {
			insert(begin(), x);
		}
		iterator erase(iterator pos) {
			assert(pos != end());
			Node* pre = pos._node->_pre;
			Node* next = pos._node->_next;
			delete pos._node ;
			pre->_next = next;
			next->_pre = pre;
			_size--;
			return next;

		}

		void pop_front() {
			erase(begin());
		}
		void pop_back() {
			erase(--end());

		}
		size_t size() const
		{
			return _size;
		}

		bool empty() const
		{
			return _size == 0;
		}


		// List Access
		T& front() {
			return begin()._node->_val;
		}
		const T& front()const {
			return begin()._node->_val;
		}
		T& back() {
			return (--end())._node->_val;
		}
		const T& back()const {
			return --end()._node->_val;
		}
	private:


		Node* _head;
		int _size;

	};
}



//不同容器的打印
template<class Container>
void  con_print(const Container & con) {
	typename Container::const_iterator it = con.begin();
	//auto it = con.begin();
	while (it != con.end())
	{

		cout << *it << " ";
		++it;
	}
	cout << endl;

	
}

 

 

 

 

 

 

 

 

 

 

羑悻的小杀马特.
关注
专栏目录
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3246
简易版list模拟实现超详解
【C++】list的模拟实现
qq_62939852的博客
03-11 1638
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 4777
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
C++——list的使用及其模拟实现
Forward♞的博客
01-28 1706
作为标准模板库中的容器，list同样也是一个类模板如果要定义一个list对象，就需要指定其存储的数据类型T。list
C++ —— 模拟实现list
weixin_59913110的博客
12-03 892
模拟实现了list容器的常用接口，初步认识模板的用法。
【C++】List模拟实现
Renswc的博客
05-31 3151
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
【C++】list类模拟实现
qq_66314292的博客
11-09 2249
list类的模拟实现
详解c++---list模拟实现
qq_68695298的博客
05-02 1051
模拟实现c++中的list
C++_list简单源码剖析：list模拟实现
Lvision2的博客
05-31 1212
->
使用c++类模板和迭代器进行List模拟实现
2301_79181624的博客
04-28 1788
对迭代器封装使得用户在使用时，不用过多的繁琐操作，仅需使用一个迭代器就好，在内部typedef使得iterator有更强的适配性。这里重载的符号为->返回的节点val值的地址，按理在调用时it->为地址，则需要。这里创建一个clear函数配合erase将节点统统释放，最后释放掉哨兵位头节点。两个版本的迭代器，自主挑选，由于前方处理过细节所以这里函数类型就不会冗余。如节点为A类型的结构体，想通过迭代器访问_a,_b，有两种方法。这里相当于对指针解引用，拿到节点，对节点直接访问。让头节点的前后指针指向自己。
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代器），并提供详细的实现代码。 首先，让...
list的讲解及模拟实现(c++)
weixin_49312527的博客
05-08 2410
与介绍vector时相同为了方便大家理解, 我们采用便模拟实现便讲解使用方式的方式, 展开对list容器的讲解. 一.list的介绍 使用时注意包含头文件: #include<list> list相关特性介绍: 1.list的底层是一个带头结点的双向循环链表. 2.list是可以在常数范围内在任意位置进行插入和删除的序列式容器, 并且该容器可以前后双向迭代. 3.list的底层是双向链表结构, 双向链表中每个元素存储在互不相关的独立节点中, 在节点中通过指针指向其前一个元素..
【C++】list的介绍及使用 | 模拟实现list | 对比vector和list
2301_76540463的博客
10-26 785
1.list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2.其底层是双向链表结构。双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3.list与forward_list非常相似。最主要的不同在于forward_list是单链表，只能朝前迭代。（这也使得它更加得简单高效）4.与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率 更好。
大话C++：第15篇 友元
最新发布
whccf的博客
10-09 937
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 943
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【C++】List
m0_46676283的博客
10-08 416
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 658
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
c语言：二叉树的创建、前序遍历、中序遍历、后续遍历
Narnat的博客
10-08 389
代码中创建的二叉树如下图。
C++之多态篇(超详细版)
2302_79795375的博客
10-04 921
public:cout
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

羑悻的小杀马特.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值