STL—List容器

最新推荐文章于 2020-07-25 00:23:25 发布
最新推荐文章于 2020-07-25 00:23:25 发布
阅读量119 收藏
点赞数
分类专栏： C++面向对象编程 文章标签： c++ stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42357849/article/details/105722572
版权
一.List介绍。
  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，让其更简单高效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息。
二.List的使用。
（一）List构造。
  1. 构造函数（ (constructor)）
  • list() ：构造空的list
  • list (size_type n, const value_type& val = value_type())： 构造的list中包含n个值为val的元素
  • list (const list& x) ：拷贝构造函数
  • list (InputIterator first, InputIterator last) 用[first, last)区间中的元素构造list（区间构造）
int main()
{
	std::list<int> l1; // 构造空的l1
	std::list<int> l2(4, 100); // l2中放4个值为100的元素
	std::list<int> l3(l2.begin(), l2.end()); // 用l2的[begin(), end()）左闭右开的区间构造l3
	std::list<int> l4(l3); // 用l3拷贝构造l4
	// 以数组为迭代器区间构造l5
	int array[] = { 16, 2, 77, 29 };
	std::list<int> l5(array, array + sizeof(array) / sizeof(int));//区间构造
	// 用迭代器方式打印l5中的元素
	for (std::list<int>::iterator it = l5.begin(); it != l5.end(); it++)
		std::cout << *it << " ";
	std::cout << endl;

	for (auto& e : l5)
		std::cout << e << " ";
	std::cout << endl;
	return 0;
}
  1. 迭代器的使用
  • begin +end
    返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
  • rbegin +rend
    返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置。
    【注意】
    (1) begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动。
    (2) rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动。
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//构造list容器
	list<int> ls(arr,arr+sizeof(arr)/sizeof(arr[0]));

	list<int>::iterator it = ls.begin();
	//正向迭代器
	while (it != ls.end())
	{
		cout << *it<<" ";
		++it;
	}
	cout << endl;
	//反向迭代器
	for (list<int>::reverse_iterator it = ls.rbegin(); it != ls.rend(); ++it)
		cout << *it << " ";
	cout << endl;

	return 0;
}
  1. list常用接口。

  • empty ：检测list是否为空，是返回true，否则返回false。

  • size ：返回list中有效节点的个数。

  • front ：返回list的第一个节点中值的引用。

  • back ：返回list的最后一个节点中值的引用。

  • push_front ：在list首元素前插入值为val的元素。

  • pop_front ：删除list中第一个元素。

  • push_back ：在list尾部插入值为val的元素。

  • pop_back： 删除list中最后一个元素。

  • insert ：在list position 位置中插入值为val的元素。

  • erase： 删除list position位置的元素。

  • swap ：交换两个list中的元素。

  • clear ： 清空list中的有效元素。
    //push_back/pop_back/push_front/pop_front：

void PrintList(list<int> L)
{
	for (auto& e : L)
		cout << e << " ";
	cout << endl;
}

void main()
{
	int array[] = { 1, 2, 3 };
	list<int> L(array, array + sizeof(array) / sizeof(array[0]));
	// 在list的尾部插入4，头部插入0
	L.push_back(4);
	L.push_front(0);
	// 删除list尾部节点和头部节点
	PrintList(L);
	L.pop_back();
	L.pop_front();
	PrintList(L);
}

// insert /erase：

void main()
{
	int array1[] = { 1, 2, 3 };
	list<int> L(array1, array1+sizeof(array1)/sizeof(array1[0]));
// 获取链表中第二个节点
	auto pos = ++L.begin();
	cout << *pos << endl;
// 在pos前插入值为4的元素
	L.insert(pos, 4);
	PrintList(L);
// 在pos前插入5个值为5的元素
	L.insert(pos, 5, 5);
	PrintList(L);
// 在pos前插入[v.begin(), v.end)区间中的元素
	vector<int> v{ 7, 8, 9 };
	L.insert(pos, v.begin(), v.end());
	PrintList(L);
// 删除pos位置上的元素
	L.erase(pos);
	PrintList(L);
// 删除list中[begin, end)区间中的元素，即删除list中的所有元素
	L.erase(L.begin(), L.end());
	PrintList(L);
}

//swap,clear

void PrintList(list<int> L)
{
	for (auto& e : L)
		cout << e << " ";
	cout << endl;
}

int main()
{
	// 用数组来构造list
	int array1[] = { 1, 2, 3 };
	list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));
	list<int> l2{ 4, 5, 6 };
	PrintList(l1);
	// 交换l1和l2中的元素
	l1.swap(l2);
	PrintList(l2);
	// 将l2中的元素清空
	l2.clear();
	cout << l2.size() << endl;
	return 0;
}
  1. list迭代器失效。
  • 迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。
void TestListIterator1()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array+sizeof(array)/sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋
值
		l.erase(it);
		++it;
		}
	}
// 改正
void TestListIterator()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, 					array+sizeof(array)/sizeof(array[0]));

	auto it = l.begin();
	while (it != l.end())
	{
		l.erase(it++); // it = l.erase(it);
	}
}

三.list模拟实现。
底层：双向循环链表：

#include<iostream>
#include<assert.h>
using namespace std;
namespace ice
{
	template<class T>
	struct _list_node//list节点
	{
		_list_node<T>* _next;//后继
		_list_node<T>* _prev;//前驱
		T _data;//值

		_list_node(const T& x = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};

	template<class T, class Ref, class Ptr>
	class _list_iterator//迭代器类
	{
		typedef _list_node<T> node;//list节点
		typedef _list_iterator<T, Ref, Ptr> Self;//迭代器
	public:
		_list_iterator(node* node)
			:_node(node)
		{}

		Ref operator*() //内置类型
		{
			return _node->_data;
		}

		Ptr operator->() //自定义类型
		{
			return &_node->_data;
		}

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

		Self operator++(int)
		{
			_list_iterator<T, Ref, Ptr> tmp(*this);
			_node = _node->_next;
			return tmp;
		}

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

		Self operator--(int)
		{
			__list_iterator<T> tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

		//it1 !=  it2
		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}

		bool operator==(const Self& it)
		{
			return _node == it._node;
		}
		//private:
		node* _node;
	};


	template<class T>
	class list//构造list类
	{
		typedef _list_node<T> node;//节点
		typedef _list_iterator<T, T&, T*> iterator;//迭代器
		typedef _list_iterator<T, const T&, const T*> const_iterator;//常迭代器
	public:
		list()//构造函数(无参)
		{
			_head = new node(T());
			_head->_next = _head;
			_head->_prev = _head;
		}

		list(const list<T>& l)
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;

			auto it = l.begin();
			while (it != l.end())
			{
				push_back(*it);
				++it;
			}
		}

		list<T>& operator=(const list<T>& l)
		{
			clear();//不要忘记清理之前的
			auto it = l.begin();
			while (it != l.end())
			{
				push_back(*it);
				++it;
			}
			return *this;
		}

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

		void push_back(const T& x)//尾插
		{
			node* newnode = new node(x);
			node* tail = _head->_prev;//先找出尾元素
			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
			//insert(end(),x);
		}

		void pop_back()//尾删
		{
			//node* tail = _head->_prev->_prev;
			//tail->_next = _head;
			//_head->_prev = tail;
			erase(--end());
		}

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

		void pop_front()//头删
		{
			erase(begin());
		}

		iterator erase(iterator pos)
		{
			node* cur = pos._node;
			assert(cur != _head);

			node* prev = cur->_prev;
			node* next = cur->_next;
			prev->_next = next;
			next->_prev = prev;

			delete cur;
			return iterator(next);
		}

		void insert(iterator pos, const T& x)
		{
			node* cur = pos._node;
			node* prev = cur->_prev;
			node* newnode = new node(x);

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
		}

		void print_list()
		{
			auto it = begin();
			while (it != end())
			{
				cout << *it << " ";
				++it;
			}
			cout << endl;
		}

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

		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);//list的 end 就是 _head
		}

		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_head);
		}
	private:
		node* _head;
	};
}

至于测试，将代码复制于编译器，自己进行插入删除操作。

ice_玖闻于世丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL常用容器详细解析
01-20
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
ICE笔记(06)：简单文件系统的设计、实现
东风
11-29 3831
【colorado】 本文介绍了比较完整的Ice应用程序，它实现了简单文件系统。本程序位于ICE发布的$ICE_HOME/demo/book/simple_filesystem目录。本文内容涉及DPWI第5，7,9章。通过这个程序的学习，读者应该掌握了Ice应用程序开发的基本方法、步骤。此后要通过深入学习Ice知识来提高Ice应用程序的开发水平。到本文为止，Ice fo
ICE简单介绍及使用示例之-复杂数据结构通信
wb175208的专栏
07-23 904
1.定义两个ice文件，第一个是数据结构文件ComplexData.ice module ComplexData { struct DataInfo{ int age; string name; double score; }; sequence<DataInfo> MyDataList; }; 第二个是接口定义文件ComplexDatainterface.ice： #include"ComplexData.ice" module MyDataInterface{ in
ICE学习（六）-Slice语言介绍
kaede999的专栏
09-17 4830
Slice语言介绍 Slice (Specification Language for Ice)语言建立了一种服务器和客户端之间的契约，他描述了接口和数据类型。这种描述和语言无关，因此，客户端和服务器不需要用同一种语言来编写。  读作 [slaɪs] 编译器可以将Slice定义编译转换为其他语言的数据类型和API。目前，支持C++, Java, C#, Python, Objective-C
关于STL中list容器的一些总结
09-05
STL中的`list`容器是基于双向链表的数据结构，这使得它在处理元素的插入和删除时具有高效性，特别是在链表的任何位置进行这些操作。然而，由于内存空间不连续，它不适合进行随机存取，因此不支持重载的`[]`操作符。 ...
STL各个容器性能详细比较
09-05
在这个场景下，我们主要关注STL中的容器，它们是存储和管理数据的主要工具。以下是STL中几种常见容器的性能比较，以及其在特定操作下的行为和效率。 1. **vector**： - **内存分配**：vector通常在内存中连续存储...
C++语言 STL容器list总结
01-21
STL 中的list 就是一 双向链表，可高效地进行插入删除元素。 list不支持随机访问。所以没有 at(pos)和operator[]。 list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) 。list< int>::iterator it; 构造...
C++中的异常捕获
weixin_42357849的博客
07-21 4060
一、概念： 1. C语言中错误处理机制： （1）终止程序，assert。通过assert终止错误，用户无法查看错误信息。 （2）返回错误代码，系统会通过醋无信心返回错误代码，程序员需要进行查看才能知道错误信息。 2. C++中的异常概念： 异常是一种错误处理方式， ...
C++11中的初始化列表，右值引入，lambda表达式等
weixin_42357849的博客
07-19 619
一、C++11的介绍： 相较于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。 二、C++11中的主要知识概念： (一）、初始化列表： 概念： ...
AVL树平衡调整与应用解析
weixin_42357849的博客
06-25 613
一、 AVL树的概念。 二、AVL树的操作。 三、AVL树的模拟实现。 四、AVL树的应用及解析。
搜索二叉树的实现与应用
weixin_42357849的博客
06-23 557
一、概念： 二、二叉搜索树的操作： 三、二叉搜索树的模拟实现：
STL关联式容器—set的使用
weixin_42357849的博客
07-17 555
一、set介绍:
C++中的几个特殊类(在堆上，栈上创建对象)
weixin_42357849的博客
07-25 538
1. 设计一个类只能在堆上创建对象。 实现方式： （1）将类的构造函数，拷贝构造函数设置为私有，防止别人调用，防止别人调用拷贝在栈上生成对象。 （2）提供静态成员函数，在函数中完成堆对象的创建。 class Base { private: Base() {} Base(const Base&) { } Base(const Base& a) = delete;//C++11的做法； public: static Base* fun() { return new Ba
文件快速搜索工具
weixin_42357849的博客
04-20 532
一.项目简介： Linux操作系统中提供了find指令查找指定文件，为了实现在Windows操作系统中实现文件的快搜搜索，利用所学知识实现文件搜索神器，与软件everything工具具有一定的相同功能，即：快速通过汉字，首字母，拼音实现文件的快速搜索。 二.项目需求及环境 （一）需求 通过首字母，汉字，拼音实现文件快速搜索。 实现搜索关键字的高亮处理。 （二）开发环境 编译器 : VS2...
C++11中线程库的使用
weixin_42357849的博客
07-19 455
线程库： 1.线程库介绍： 在C++11之前，涉及到多线程问题，都是和平台相关的，比如windows和linux下各有自己的接口，这使得代码的可移植性比较差。C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含< thread >头文件。 2. 线程库函数的使用： thread() 构造一个线程对象，没有关联任何线程函数，即没有启动任何线程 thread(fn,args1,
泛化编程和模板的使用
weixin_42357849的博客
04-13 421
在学习的过程中，我们在写代码的时候会使用一些形式相同，参数相同，但参数类型和返回值类型不同的一些函数。当初我们学过函数重载，但函数重载存在以下一些不好的地方。 -例如： 重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数。 代码的可维护性比较低，一个出错可能所有的重载均出错。 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的...
数据结构—红黑树(BRTree树)的认识
weixin_42357849的博客
07-06 386
一、红黑树的概念： 红黑树：是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。 红黑树的性质：（一头一脚黑，黑同红不同） （1）每个结点不是红色就是黑色 （2）根节点是黑色的 （3）如果一个节点是红色的，则它的两个孩子结点是黑色的 （4）对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 （5） 每个叶子结点都是黑色的(
C++中的重载，覆盖，和重定义（同名隐藏）
weixin_42357849的博客
06-16 384
一、基础概念 重载：函数在同一作用域中，且函数名字相同，参数列表不同。 注意：只有返回值不同的函数不能构成重载。 覆盖：两个函数分别在基类和子类里，基类中的函数必须是虚函数，子类必须重写父类的方法。 注意：基类和子类的两个函数都是虚函数。虽然子类重写父类的虚函数时有时候不加virtual,但子类的函数也是虚函数。 重定义：两个函数分别在子类和父类，两函数的函数名相同，在继承中，子类会隐藏父类的方法。 注意： （1）如果派生类的函数与基类的函数同名，参数不相同，此时，不论有无virtual关键字，基类的函数
C++基础入门必知
weixin_42357849的博客
11-05 298
#1、C++关键字。 C++中关键字很多，例如：class、auto、bool、break、static等，还包括C语言中的一些关键字，这些关键字在C++的学习中非常重要，相信在以后的学习中你会慢慢了解的更透彻。 #2、命名空间。 （1）在C/C++中，变量、函数和都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以...
用STL List容器编写矩阵就地转置
最新发布
05-24
下面是使用STL List容器实现矩阵就地转置的代码： ```c++ #include #include <list> using namespace std; // 矩阵就地转置函数 void transpose(list<list<int>>& matrix) { // 获取矩阵的行数和列数 int rows ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值