【C++第十课 - List】List的使用、list底层实现、list的const迭代器实现、反向迭代器

已于 2024-07-17 09:44:17 修改
阅读量1.1k 收藏 27
点赞数 24
分类专栏： C++ 文章标签： c++ list windows
于 2024-06-19 10:38:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60803455/article/details/139565999
版权

目录

一、List的使用

补充
需要使用类域指向的：
1、内部类
2、类里面typedef的

构造函数

（1）构造一个空的list
（2）构造一个list，它里面的数据是n个val
（3）用迭代区间构造list
（4）用已有的一个list构造另一个list
在这里插入图片描述

List就是一个带头双向循环列表

List不支持[]
没有扩容什么的概念了

1、遍历

（1）迭代器
在这里插入图片描述
在这里插入图片描述

（2）范围for
但范围for的底层和迭代器没有区别

	list<double> l2(5, 6.6);
	for (auto e : l2)
	{
		cout << e << " ";
	}
	cout << endl;

在这里插入图片描述

2、reverse

逆置
在这里插入图片描述

	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	
	list<int>::iterator it = l1.begin();
	while (it != l1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	l1.reverse();
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;

在这里插入图片描述

3、merge

归并：将两个有序的列表归并成一个有序的

使用merge的时候，可以先对列表进行sort排序
在这里插入图片描述

void test2()
{
	list<int> l1;
	l1.push_back(3);
	l1.push_back(5);
	l1.push_back(2);
	l1.push_back(9);
	l1.sort();
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
	list<int> l2;
	l2.push_back(13);
	l2.push_back(15);
	l2.push_back(22);
	l2.push_back(19);
	l2.sort();
	for (auto e : l2)
	{
		cout << e << " ";
	}
	cout << endl;

	l1.merge(l2);
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述

4、unique

去重：一般要求有序，无序必须相同的值是挨着的
在这里插入图片描述

void test3()
{
	list<int> l1;
	l1.push_back(3);
	l1.push_back(5);
	l1.push_back(2);
	l1.push_back(9);
	l1.push_back(2);
	l1.push_back(2);
	l1.push_back(9);
	l1.sort();
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
	l1.unique();
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述

5、sort

排序

list不能用算法库里面的sort，算法库里面的sort是快排（需要连续的空间，原地排序，不稳地排序，O(n2)），list自带的sort是归并(稳定排序，O(nlogn))
vector的排序用的是递归
实际中排序：拷贝到vector，进行排序，排完再assign到list里面

在这里插入图片描述

6、remove

相当于先find再删
在这里插入图片描述

void test4()
{
	list<int> l1;
	l1.push_back(3);
	l1.push_back(5);
	l1.push_back(2);
	l1.push_back(100);
	l1.push_back(9);
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
	l1.remove(100);
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述

7、splice

把一个链表的值转移到另一个链表，是把一个链接里面的节点直接拿走
在这里插入图片描述

void test5()
{
	list<int> l1;
	l1.push_back(3);
	l1.push_back(5);
	l1.push_back(2);
	l1.push_back(100);
	l1.push_back(9);
	cout << "l1:";
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
	list<int> l2;
	l2.push_back(13);
	l2.push_back(15);
	l2.push_back(22);
	l2.push_back(19);
	cout << "l2:";
	for (auto e : l2)
	{
		cout << e << " ";
	}
	cout << endl;
	l1.splice(l1.begin(), l2);
	cout << "l1:";
	for (auto e : l1)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << "l2:";
	for (auto e : l2)
	{
		cout << e << " ";
	}
	cout << endl;
}

在这里插入图片描述

二、底层实现

1、带头双向循环列表

struct和class的区别
（1）继承权限：struct默认为public，而class默认的为private。
（2）访问权限：struct默认的成员变量访问控制权限是public，而class默认的成员变量访问权限则为private。
（3）class可以用于定于template，struct不能。
列表节点的定义

template<class T>
	struct ListNode 
	{
		ListNode(const T& x = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(x)
		{}

		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _data;
	};

列表的定义

template<class T>
	class list
	{
		
	public:
		typedef ListNode<T> Node;
		typedef __listiterator<T> iterator;
		list()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}

		void push_back(const T& x)
		{
			Node* tmp = new Node(x);
			Node* tail = _head->_prev;
			tail->_next = tmp;
			tmp->_prev = tail;
			_head->_prev = tmp;
			tmp->_next = _head;
		}
	private:
		Node* _head;
	};

2、迭代器

Node是自定义类型，但Node*是内置类型，是要改变的是Node*的指向，不能改变指针的运算符
对Node*类型进行运算符重载，但Node*是内置类型无法运算符重载，因此需要套一个类__listiterator

namespace zyh
{
	template<class T>
	struct ListNode 
	{
		ListNode(const T& x = T())
			:_prev(nullptr)
			,_next(nullptr)
			,_data(x)
		{}

		ListNode<T>* _prev;
		ListNode<T>* _next;
		T _data;
	};
	template<class T>
	struct __listiterator
	{
		typedef ListNode<T> Node;
		typedef __listiterator self;
		Node* _node;
		__listiterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		bool operator!=(const self& x)
		{
			return _node != x._node;
		}
		T operator*()
		{
			return _node->_data;
		}
	};

	template<class T>
	class list
	{
		
	public:
		typedef ListNode<T> Node;
		typedef __listiterator<T> iterator;
		list()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}

		void push_back(const T& x)
		{
			Node* tmp = new Node(x);
			Node* tail = _head->_prev;
			tail->_next = tmp;
			tmp->_prev = tail;
			_head->_prev = tmp;
			tmp->_next = _head;
		}
		iterator begin()
		{
			//return iterator(_head->_next);
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
	private:
		Node* _head;
	};

	void list_test1()
	{
		list<int> lt1;
		lt1.push_back(10);
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(9);
		lt1.push_back(3);
		list<int>::iterator it = lt1.begin();
		while (it != lt1.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
}

在这里插入图片描述

3、迭代器的补充

这些都是在__listiterator类里面
（1）前置++：self& operator++()

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

（2）后置++：self& operator++(int)

		self& operator++(int)
		{
			//Node* tmp = _node;
			self tmp(*this);
			_node = _node->_next;
			return tmp;

（3）前置- -：self& operator--()

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

（3）后置- -：self& operator--(int)

		self& operator--(int)
		{
			Node* tmp = _node;
			_node = _node->_prev;
			return tmp;
		}

迭代器这个类里面没有析构函数
默认的析构函数对类里面的成员是不做处理的
这个类里面没有写析构函数，是因为这个类只是listnode的节点给它访问，他不能把人家删除吧

4、insert

不存在迭代器失效的问题

		void insert(const iterator pos, const T& x)
		{
			Node* tmp = new Node(x);
			Node* forward = (pos._node)->_prev;
			forward->_next = tmp;
			tmp->_prev = forward;
			tmp->_next = pos._node;
			(pos._node)->_prev = tmp;

		}

5、push_front

不存在迭代器失效问题

		iterator push_front(const T& x)
		{
			Node* tmp = new Node(x);
			tmp->_next = begin();
			tmp->_prev = end();
			end()._node->_next = tmp;
			begin()._node->_prev = tmp;
			return tmp;
		}

6、erase

pos迭代器失效问题

		iterator erase(iterator& pos)
		{
			assert(pos != end());
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			delete pos._node;
			prev->_next = next;
			next->_prev = prev;
			return next;
		}

7、析构和clear

析构：列表的所以节点要释放，哨兵位的头节点也要释放
clear：只释放列表的所以节点，哨兵位的头节点不释放

clear

		bool empty()
		{
			if (_head->_next == _head->_prev)
				return true;
			else
				return false;
		}
		void clear()
		{
			if (empty())
				return;
			Node* cur = _head->_next;
			while (cur != _head)
			{
				Node* prev = cur->_prev;
				Node* next = cur->_next;
				prev->_next = next;
				next->_prev = prev;
				delete cur;
				cur = next;
			}
		}

问题：写的过于复杂，可以复用erase

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

注意：it = erase(it)这里一定要再赋值给it，因为erase之后的it就是失效了

析构

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

8、拷贝构造

没有加const迭代器

		//list(const list<T>& x)
		list(list<T>& x)
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
			iterator it = x.begin();
			while (it != x.end())
			{
				push_back(*it);
				++it;
			}
		}

9、赋值=

		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

10、const迭代器

传参的时候会有const的对象

const迭代器不是自身不能修改，是指向的内容不能被修改
const迭代器不是const对象，自己可以修改

const迭代器 - 第一版
与普通迭代不同的地方
__const_listiterator类里面
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

	template<class T>
	struct __const_listiterator
	{
		typedef ListNode<T> Node;
		typedef __const_listiterator self;
		Node* _node;
		__const_listiterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self& operator++(int)
		{
			//Node* tmp = _node;
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		bool operator!=(const self& x)
		{
			return _node != x._node;
		}
		const T& operator*()
		{
			return _node->_data;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self& operator--(int)
		{
			Node* tmp = _node;
			_node = _node->_prev;
			return tmp;
		}
	};

list类里面
在这里插入图片描述

	template<class T>
	class list
	{
		
	public:
		typedef ListNode<T> Node;
		typedef __listiterator<T> iterator;
		typedef __const_listiterator<T> const_iterator;
		list()
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}
		//list(const list<T>& x)
		list(list<T>& x)
		{
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
			iterator it = x.begin();
			while (it != x.end())
			{
				push_back(*it);
				++it;
			}
		}
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		void push_back(const T& x)
		{
			Node* tmp = new Node(x);
			Node* tail = _head->_prev;
			tail->_next = tmp;
			tmp->_prev = tail;
			_head->_prev = tmp;
			tmp->_next = _head;
		}
		iterator begin()
		{
			//return iterator(_head->_next);
			return _head->_next;
		}
		iterator end()
		{
			return _head;
		}
		const_iterator begin() const
		{
			return _head->_next;
		}
		const_iterator end() const
		{
			return _head;
		}
		iterator insert(const iterator pos, const T& x)
		{
			Node* tmp = new Node(x);
			Node* forward = (pos._node)->_prev;
			forward->_next = tmp;
			tmp->_prev = forward;
			tmp->_next = pos._node;
			(pos._node)->_prev = tmp;
			return tmp;
		}
		//iterator push_front(const T& x)
		//{
		//	Node* tmp = new Node(x);
		//	tmp->_next = begin();
		//	tmp->_prev = end();
		//	end()._node->_next = tmp;
		//	begin()._node->_prev = tmp;
		//	return tmp;
		//}
		iterator push_front(const T& x)
		{
			return insert(begin(), x);
		}
		iterator erase(iterator pos)
		{
			assert(pos != end());
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			delete pos._node;
			prev->_next = next;
			next->_prev = prev;
			return next;
		}
		iterator pop_back()
		{
			return erase(--end());
		}
		iterator pop_front()
		{
			return erase(begin());
		}
		bool empty()
		{
			if (_head->_next == _head->_prev)
				return true;
			else
				return false;
		}
		//void clear()
		//{
		//	if (empty())
		//		return;
		//	Node* cur = _head->_next;
		//	while (cur != _head)
		//	{
		//		Node* prev = cur->_prev;
		//		Node* next = cur->_next;
		//		prev->_next = next;
		//		next->_prev = prev;
		//		delete cur;
		//		cur = next;
		//	}
		//}
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}


	private:
		Node* _head;
	};

问题：迭代器的类和const迭代器的类两个类有点冗余
const迭代器 - 第二版

template<class T, class Ref>
	struct __listiterator
	{
		typedef ListNode<T> Node;
		typedef __listiterator self;
		Node* _node;
		__listiterator(Node* node)
			:_node(node)
		{}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self& operator++(int)
		{
			//Node* tmp = _node;
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		bool operator!=(const self& x)
		{
			return _node != x._node;
		}
		Ref operator*()
		{
			return _node->_data;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self& operator--(int)
		{
			Node* tmp = _node;
			_node = _node->_prev;
			return tmp;
		}
	};

在这里插入图片描述

在const迭代器中实现->的运算符重载
当ListNode里面的data是个结构体时，使用->进行访问

11、反向迭代器

（1）系统内的反向迭代器
rend就是begin的位置，rbeigin就是end的位置，形成了一种对称。
在这里插入图片描述
在这里插入图片描述
（2）自己实现的反向迭代器
ReverseIterator

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

template<class iterator, class Ref, class Ptr>
struct __reverse_iterator
{
	iterator _cur;
	typedef __reverse_iterator<iterator, Ref, Ptr> self;
	__reverse_iterator(iterator x)
		:_cur(x)
	{}

	self& operator++()
	{
		--_cur;
		return *this;
	}
	self& operator--()
	{
		++_cur;
		return *this;
	}
	Ref operator*()
	{
		iterator tmp = _cur;
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &_cur;
	}
	bool operator!=(const self& x)
	{
		return _cur != x._cur;
	}
};

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

芒果329
关注
专栏目录
List的迭代器
Lemon
10-29 3772
引自"C++ primer plus 6"中的话: 理解迭代器是理解STL的关键所在。 模板使得算法独立于存储的数据类型，而迭代器使算法独立于使用的容器类型。 因此，它们都是STL通用方法的重要组成部分。 一直觉得迭代器很神秘，在调试了简单的List迭代器之后，才认识到迭代器实质上就是遍历访问容器里面的元素。不同的容器，它的遍历方式不同，迭代器也就各不相同。 数组下标的移动和指针的++就
C++ STL - list 模拟实现+解析迭代器
TPON的博客
10-12 1027
STL - list iterator const_iterator reverse_iterator 模拟实现
list+迭代器（C++）简单操作
xiaonuolen
11-16 5278
#include&lt;iostream&gt; #include&lt;list&gt; using namespace std; int main(){     list&lt;int&gt; list1;     list1.push_back(1);     list1.push_back(2);     list1.push_back(3);     list&lt;int&gt;::i...
C++——list
最新发布
2301_79998744的博客
10-05 2412
list的模拟实现
C++之List
LC900730的博客
07-12 810
双向链表容器，可以高效插入与删除元素 不可以随机存取元素，即不能at与[]； 迭代器可以++，可以–，但是不能+5，-5等list的删除元素是左闭右开。 //插入元素 链表的起始位置是0，那么插入元素3，就是原来的第3个就会变成第4个insert(it,100);//那么插入后 list.clear();移除容器中所有数据 list,erase(beg,end);删除[beg,end)元素之
C++ 之List
zyc2018的博客
02-24 341
C++list的使用总结及常用list操作：https://blog.csdn.net/fanyun_01/article/details/56881515 一、List定义： Lists将元素按顺序储存在链表中。与 向量(vectors)相比，它允许快速的插入和删除，但是随机访问却比较慢。 使用时需要添加头文件#include<list> 二、List定义和初始化： ...
C++ list
Claroja
04-02 534
链表(非连续,非顺序存储结构,由数据域和指针域构成). list是循环双向链表 1.动态分配内存,不会额外申请空间 2.插入删除快 3.额外的指针域耗费比较大 构造函数 方法 描述 list lstT; 默认构造形式： list(beg,end); 构造函数将[beg, end)区间中的元素拷贝。 list(n,elem); 构造函数将n个elem拷贝给。 list(c...
【C++ STL】list 容器（介绍、使用、@迭代器失效、@迭代器的分类与实现方式、模拟实现、list 和 vector 的对比）
codewinter的博客
05-25 1219
文章目录一、STL - list 的介绍二、list 的使用2.1 常见构造2.2 迭代器及其遍历操作2.3 容量操作2.4 访问操作2.5 修改操作① 迭代器失效（⭐）② 成员 / 非成员 swap 函数2.6 容器操作（了解，用的很少）三、容器迭代器（重要）3.1 容器迭代器的分类（⭐重要）3.2 迭代器的实现方式分析（⭐重要）四、stl_list 源码剖析4.1 list 的底层结构五、list 的模拟实现5.1 list 的节点结构5.2 list 的迭代器（⭐重要）① 迭代器的结构② 一些思考（⭐
【C++】STL——list（部分功能模拟实现、迭代器、反向迭代器）
小胡同学的博客
05-23 312
STL中的list底层实现是用带头循环的双链表，这种结构设计巧妙的使得list能够在随机位置插入删除的效率搞，但处理不了大量数据，相比于vector，vector的随机位置删除的速度就低于list ，因为vector需要挪动数据，而list直接把链子相接就可以了那么list在使用的时候不难，stl的容器相似性很强，所以这次list的实现能更让我们学会c++关于封装的理解，c++类和对象的巩固，通过各种模板的类型，迭代器的封装，反向迭代器的封装使用。
《STL容器篇》-List模拟实现（三种反向迭代器）
m0_62171658的博客
07-21 229
是因为如果T为结构，它里面有int_a和int_b，我们可以*it._a和*it._b来访问T，但我们有的时候就想直接it->_a和it->_b来访问T的两个元素，因此我们可以重载operator->，本质上我们应该这样使用it->->_a，it->->_b，但编译器会优化，我们只需要it->_a、it->_b即可。我们很容易知道的是，反向迭代器就是正向迭代器的一层封装，用正向迭代器就可以适配出反向迭代器，这里我设计出了一个反向迭代器的模板，只要传任何容器的正向迭代器就能生成对应的反向迭代器。...
C++迭代器介绍（iterator、const_iterator、reverse_interator、const_reverse_interator）
12-20
C++的迭代器是STL（Standard Template Library）的核心组件之一，它允许程序员像操作普通指针一样遍历容器中的元素，但具有更多的安全性和灵活性。迭代器扮演着“智能指针”的角色，它可以指向容器内的元素，提供了...
C++ list
开心小月半子
05-31 1296
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素，但是随机访问却比较慢。list不支持随机存取，要访问第n个元素，必须先遍历前n-1个元素才能访问第n个元素。因此，list没有下标[ ]操作，也没有at()接口。 初始化： list<int> test; 用法： te...
【C++】STL—容器—list介绍
zhao_leilei的博客
11-11 887
文章目录1、list的概念2、list的使用2.1 list的构造2.2 list迭代器的使用2.3 list节点个数2.4 list元素访问2.5 list元素修改2.6 list迭代器失效3.list的模拟实现4.list和vector的区别 1、list的概念 list是带头结点的循环双向链表，是可以在常数范围内在任意位置进行插入和删除的序列式容器。 2、list的使用 list中的接口比较多，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接
C++ List
Ferlan的博客
08-07 579
#include&amp;amp;lt;iostream&amp;amp;gt; #include&amp;amp;lt;assert.h&amp;amp;gt; using namespace std; typedef int DataType; struct Listnode { DataType _data; Listnode* _next; Listnode* _prev; Listnode()
C++ List
柯拉的博客
04-21 561
#include <iostream> #include <list> using namespace std; int main() { list<int> li = { 1,2,3 }; li.push_front(4); //在 list开端进行插入 li.push_back(5);//在list末尾进行插入 auto ...
C++迭代器模式深入学习与应用
- 一个聚合类可以有多种不同类型的迭代器，例如正向迭代器、反向迭代器，或者读写迭代器等，以满足不同场景下的需求。 - 在C++中，迭代器失效问题需要特别注意。迭代器失效是指当容器中的元素被修改或者删除时，原先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值