【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
关注
  • 24
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ list
开心小月半子
05-31 1221
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素，但是随机访问却比较慢。list不支持随机存取，要访问第n个元素，必须先遍历前n-1个元素才能访问第n个元素。因此，list没有下标[ ]操作，也没有at()接口。 初始化： list<int> test; 用法： te...
C++之List
LC900730的博客
07-12 764
双向链表容器，可以高效插入与删除元素 不可以随机存取元素，即不能at与[]； 迭代器可以++，可以–，但是不能+5，-5等list的删除元素是左闭右开。 //插入元素 链表的起始位置是0，那么插入元素3，就是原来的第3个就会变成第4个insert(it,100);//那么插入后 list.clear();移除容器中所有数据 list,erase(beg,end);删除[beg,end)元素之
C++中的list
最新发布
m0_73968399的博客
05-30 2641
C++中的容器list
C++ 之List
zyc2018的博客
02-24 314
C++list的使用总结及常用list操作：https://blog.csdn.net/fanyun_01/article/details/56881515 一、List定义： Lists将元素按顺序储存在链表中。与 向量(vectors)相比，它允许快速的插入和删除，但是随机访问却比较慢。 使用时需要添加头文件#include<list> 二、List定义和初始化： ...
C++迭代器介绍（iterator、const_iterator、reverse_interator、const_reverse_interator）
12-20
C++的迭代器是STL（Standard Template Library）的核心组件之一，它允许程序员像操作普通指针一样遍历容器中的元素，但具有更多的安全性和灵活性。迭代器扮演着“智能指针”的角色，它可以指向容器内的元素，提供了...
C++ 自实现的List
04-11
实际实现时还需要考虑其他功能，如迭代器、反向遍历、插入操作、查找操作等，以及错误处理和内存管理，以确保代码的完整性和健壮性。此外，为了提高效率，可以考虑使用智能指针（如`std::unique_ptr`）来自动管理...
C++设计模式编程中的迭代器模式应用解析
09-02
在C++中，迭代器模式通常通过定义一个迭代器类来实现，该类知道如何遍历集合对象的元素。迭代器具有向前移动的能力，可以访问下一个元素，直到达到集合的结尾。在C++标准库（STL）中，已经内置了对迭代器的支持，...
at42ft_containers：重新实现STL中的某些容器（矢量，列表，地图，堆栈，队列和＆及其迭代器，const_iterators，reverse_iterators）[C ++]
02-20
本项目“at42ft_containers”旨在重新实现STL中的部分核心容器，包括矢量（vector）、列表（list）、地图（map）、堆栈（stack）、队列（queue）以及相关的迭代器（iterators），如const_iterators和reverse_...
什么是C++的迭代器.docx
10-23
更高级的迭代器支持更复杂的功能，如反向迭代器（reverse_iterator）用于反向遍历容器，以及输入和输出迭代器用于I/O操作。 总的来说，C++的迭代器是C++标准库中实现泛型编程和容器操作的核心工具，它们为程序员...
C++ list
Claroja
04-02 519
链表(非连续,非顺序存储结构,由数据域和指针域构成). list是循环双向链表 1.动态分配内存,不会额外申请空间 2.插入删除快 3.额外的指针域耗费比较大 构造函数 方法 描述 list lstT; 默认构造形式： list(beg,end); 构造函数将[beg, end)区间中的元素拷贝。 list(n,elem); 构造函数将n个elem拷贝给。 list(c...
【C++】STL—容器—list介绍
zhao_leilei的博客
11-11 749
文章目录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 525
#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 529
#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++ list
weixin_41167925的博客
09-17 1026
转自https://blog.csdn.net/abc882715/article/details/78783792 Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢. assign() 给list赋值 back() 返回最后一个元素 begin() 返回指向第一个元素的迭代器 clear() 删除所有元素 empty() 如果list是空的则返回true end() 返回末尾的迭代器 erase() 删除一个元素 fron
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值