C++【STL】之list的使用

最新推荐文章于 2024-04-14 13:47:32 发布
最新推荐文章于 2024-04-14 13:47:32 发布
阅读量1.3k 收藏 3
点赞数 4
分类专栏： C++ 文章标签： c++ 开发语言 STL list 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cw412524/article/details/131255968
版权

文章目录：

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使用

本文介绍的是list的部分常用接口，大佬们想了解更多关于list类的细节，一定要请前往官方文档（点击跳转）查阅学习！

1. 默认成员函数

1.1 构造函数

list支持三种构造方式：

  • 默认构造：构造一个list对象，此时只有一个哨兵位节点
  • 带参构造：构造一个list对象，初始化对象有n个val值的节点
  • 迭代器区间构造：根据传入的迭代器区间，构造出目标区间值的list对象
int main()
{
	vector<int> arr = { 1,2,3,4,5,6 };
	list<int> l1; //默认构造
	list<int> l2(8, 1); //带参构造，8个val值为1的节点
	list<int> l3(arr.begin(), arr.end()); //迭代器区间构造
	return 0;
}

1.2 拷贝构造

拷贝已有的list对象来构造出一个新的相同值对象

int main()
{
	list<int> l1(3, 6);
	list<int> l2(l1);

	cout << "l1: ";
	for (auto e : l1) cout << e << " ";
	cout << endl;

	cout << "l2: ";
	for (auto e : l2) cout << e << " ";
	return 0;
}

1.3 赋值重载

将原有list对象的值赋值给另一个已存在的对象

int main()
{
	const char* ps = "happy new year";
	list<char> l1(ps, ps + strlen(ps)); //源对象
	list<char> l2; //目标对象
	l2 = l1;
	for (auto e : l2) cout << e;
	return 0;
}

注意： 即使目标对象比源对象小，也能进行赋值

1.4 析构函数

析构函数会在对象生命周期结束时自动调用，进行内存释放，调用后哨兵位也将被释放

2. 迭代器

由于list的空间不是连续的，所以它的迭代器是不同于string和vector的随机迭代器的，list类中使用的是双向迭代器，只能做单纯的双向移动

list中的迭代器

  • 正向迭代器iterator
  • 反向迭代器reveser_iterator
  • const版本正反迭代器
int main()
{
	string str = "hello world";
	list<char> l1(str.begin(), str.end()); //迭代器区间构造
	//正向遍历
	list<char>::iterator it = l1.begin();
	while (it != l1.end())
	{
		cout << *it;
		it++;
	}
	cout << endl;
	//反向遍历
	list<char>::reverse_iterator rit = l1.rbegin();
	while (rit != l1.rend())
	{
		cout << *rit;
		rit++;
	}
	return 0;
}

因为list 的空间不是连续的，所以不支持下标的随机访问，对 list 对象进行遍历时，只能使用迭代器

3. 容量操作

empty()接口：判空

size()接口：查看大小

max_size()接口：检查大小调整时的合法性

int main()
{
	list<int> l1(88, 6);
	cout << l1.size() << endl; 
	cout << l1.empty() << endl;
	cout << l1.max_size() << endl;
	return 0;
}

4. 数据访问

front()接口：访问哨兵位的下一个节点

back()接口：访问链尾数据

int main()
{
	vector<int> v = { 4,1,2 };
	list<int> l1(v.begin(), v.end()); //迭代器区间构造
	cout << "front: " << l1.front() << endl;
	cout << "back: " << l1.back() << endl;
	return 0;
}

5. 数据修改

5.1 插入删除

assign()接口：赋值

push_front()接口：头插

pop_front()接口：头删

push_back()接口：尾插

pop_back()接口：尾删

int main()
{
	vector<int> vs = { 4,1,2 };
	list<int> l1(vs.begin(), vs.end());
	for (auto e : l1) cout << e << " "; //4 1 2
	cout << endl;

	l1.assign(3, 6); //赋值为3个6
	for (auto e : l1) cout << e << " "; //6 6 6
	cout << endl;

	l1.push_front(12); //头插12
	for (auto e : l1) cout << e << " "; //12 6 6 6
	cout << endl;

	l1.pop_front(); //头删
	for (auto e : l1) cout << e << " "; //6 6 6
	cout << endl;

	l1.push_back(24); //尾插24
	for (auto e : l1) cout << e << " "; //6 6 6 24
	cout << endl;

	l1.pop_back(); //尾删
	for (auto e : l1) cout << e << " "; //6 6 6 
	cout << endl;
	return 0;
}

list对于首尾数据的操作效率很高

insert()接口：任意位置插入

erase()接口：任意位置删除

任意位置的操作需要配合迭代器和全局查找函数find()使用，一段数据中如果有相同值，find()会返回第一次找到的位置

int main()
{
	vector<int> vv = { 4,1,2 };
	list<int> l1(vv.begin(), vv.end());
	for (auto e : l1) cout << e << " "; //4 1 2
	cout << endl;

	auto poss = find(l1.begin(), l1.end(), 2);
	l1.insert(poss, 6); //指定位置插入6
	for (auto e : l1) cout << e << " "; //4 1 6 2
	cout << endl;

	l1.insert(poss, 3, 8); //指定位置插入3个8
	for (auto e : l1) cout << e << " "; //4 1 6 8 8 8 2
	cout << endl;

	l1.insert(poss, vv.begin(), vv.end()); //指定位置插入一段数据
	for (auto e : l1) cout << e << " "; //4 1 6 8 8 8 4 1 2 2
	cout << endl;

	poss = find(l1.begin(), l1.end(), 1);
	l1.erase(poss); //删除指定位置的值
	for (auto e : l1) cout << e << " "; //4 6 8 8 8 4 1 2 2
	cout << endl;

	l1.erase(l1.begin(), l1.end()); //全删
	for (auto e : l1) cout << e << " ";
	return 0;
}

注意：

erase后会存在迭代器失效问题，需要及时更新迭代器位置！！！

5.2 交换调整清理

swap()接口：list对象交换

resize()接口：调整大小，若调整后的大小大于原大小，会尾插T()的值

clean()接口：清理

void Print(list<int>& l1, list<int>& l2)
{
	cout << "l1 size(): " << l1.size() << endl;
	for (auto e : l1) cout << e << " ";
	cout << endl;

	cout << "l2 size(): " << l2.size() << endl;
	for (auto e : l2) cout << e << " ";
	cout << endl;
	cout << "--------------------" << endl;
}

int main()
{
	vector<int> vc = { 4,1,2 };
	list<int> l1(vc.begin(), vc.end());
	list<int> l2(vc.rbegin(), vc.rend());
	Print(l1, l2);

	l1.swap(l2); //交换l13和l14
	Print(l1, l2);

	l1.resize(1); //调整大小为1
	l2.resize(12); //调整大小为12
	Print(l1, l2);

	l2.clear(); //清理l13
	Print(l2, l2);
	return 0;
}

6. 其他操作

list类中还有诸如拼接、移除、逆置等操作，特殊场景使用起来很方便

6.1 链表拼接

splice()接口：对原链表中指定区间进行拼接，拼接后，原位置处的节点(区间)不再有，已被拼接到其他地方

void Print(list<int>& l1, list<int>& l2)
{
	cout << "l1: ";
	for (auto e : l1) cout << e << " ";
	cout << endl;

	cout << "l2: ";
	for (auto e : l2) cout << e << " ";
	cout << endl;
	cout << "--------------------" << endl;
}

int main()
{
	vector<int> vx = { 1, 2, 3, 4, 5, 6 };
	list<int> l1(vx.begin(), vx.begin() + 3); //123
	list<int> l2(vx.begin() + 3, vx.end()); //456
	Print(l1, l2);

	l1.splice(l1.end(), l2);	//l2拼接到l1的结尾
	Print(l1, l2);

	l1.splice(l1.end(), l1, l1.begin()); //拼接到结尾
	Print(l1, l2);

	auto first = l1.begin();
	first++;	//指向第二个节点
	auto last = l1.end();	//指向最后一个节点
	l1.splice(l1.begin(), l1, first, last);	//拼接到开头
	Print(l1, l2);
	return 0;
}

6.2 链表移除

remove()接口：这个接口就是find() + erase()的封装版，使用起来非常方便

int main()
{
	vector<int> va = { 4,1,2 };
	list<int> l1(va.begin(), va.end());
	for (auto e : l1) cout << e << " ";
	cout << endl;

	l1.remove(2); //移除元素2
	for (auto e : l1) cout << e << " ";
	cout << endl;
	return 0;
}

6.3 排序

由于库中的排序std::sort使用的是快排，需要支持下标随机访问，所以list对象不能使用，list类自己也提供了排序算法，不过效率较低，还不如先将数据拷贝到vector中，排序完后再拷贝回来的效率高

下面一段代码就是测试两种排序方法的效率：

int main()
{
	srand((size_t)time(NULL)); //随机数
	int n = 10000000;
	vector<int> tmp;
	tmp.reserve(n);
	list<int> l1;
	list<int> l2;
	int val = 0;
	int i = 0;
	while (i < n)
	{
		//放入随机数
		val = rand() % 100 + 1;
		l1.push_back(val);
		l2.push_back(val);
		i++;
	}
	//使用list::sort 排序
	int begin1 = clock();
	l1.sort();
	int end1 = clock();
	
	int begin2 = clock();
	//先拷贝到vector中
	for (auto e : l2)
	{
		tmp.push_back(e);
	}
	//使用std::sort 排序（快排）
	std::sort(tmp.begin(), tmp.end());
	//再拷贝回去
	int pos = 0;
	for (auto& e : l2)
	{
		e = tmp[pos++];
	}
	int end2 = clock();
	cout << "list::sotr time is: " << end1 - begin1 << endl;
	cout << "std::sort time is: " << end2 - begin2 << endl;

	return 0;
}

6.4 链表逆置

reverse()接口：将list对象逆置

int main()
{
	string ss = "happy";
	list<char> l1(ss.begin(), ss.end());
	for (auto e : l1) cout << e;
	cout << endl;

	l1.reverse();
	for (auto e : l1) cout << e;
	cout << endl;
	return 0;
}

C++【STL】之list的使用，到这里就介绍结束了，本篇文章对你由帮助的话，期待大佬们的三连，你们的支持是我最大的动力！

文章有写的不足或是错误的地方，欢迎评论或私信指出，我会在第一时间改正！

茉莉蜜茶v
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
c++ STL之list对结构体的增加,删除,排序等操作详解
01-19
对STL中的list进一步学习,编程过程中对结构体的操作很多。 全部代码如下： /* Project:list对结构体的使用 Date: 2018/07/14 Author: Frank Yu 常用函数:int size() 返回容器元素个数；bool empty() 判断容器...
C++实现STL容器之List
04-08
C++实现STL容器之List
如何复制list
gaoyan601的博客
11-07 1544
在java中，对list的操作会直接影响和它有关系任何其他变量。分为两种情况 1. 如：有两个list   List a = new ArralyList(); List b = new ArralyList(); 如果简单的进行a=b,那么在稍后的操作中，对b进行任何操作，a都会受影响，如执行b.clear()，那么a也会被clear掉。 2. 存在两个list
【C++序列式容器】list
Qiuhan_909的博客
03-27 729
C++序列式容器之list
C++中的STL——list类的基本使用
最新发布
小何代码咖啡馆
04-14 838
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
C++List详解
m0_53889456的博客
05-11 6742
list容器详解，学我这一篇就够了。你写的C++list到底有什么不一样？都让人写烂的东西了你怎么还写？你比别人强？点进来看看你就知道有什么不一样了。
【剑指offer】面试题35：复杂链表的复制（Java）
hx1043116928的博客
03-05 594
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。 示例 1： 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]] 输出：[[7,null],[13,0],[11,4],[10,2],[1,0]] 示例...
C++STL——list容器及其常用操作（详解）
阿标de杂货铺
07-27 2485
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域。另一个是存储下一个结点地址的指针域。list容器的数据结构是一个双向循环链表。链表其优缺点为：采用动态存储分配，不会造成内存浪费和溢出，链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素，链表灵活，但是空间和时间额外耗费较大
【c++】STL之list用法总结
01-08
与之相似的forward_list是单向链表，可以理解为forward_list是一个行动受限的list，凡是list没提供的功能，forward_list也不提供，forward_list的优点是内存用量少，行动也略快速。 list不支持随机访问。如果你要...
c模拟c++ stl list
06-18
实现c++ list部分功能，内存自管理 函数的使用和c++ stl list类似，并不完全相同 简单测试过，并不保证完全无错，仅供参考
C++语言 STL容器list总结
01-21
在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表，可高效地...
C++ STL --- list的使用
weixin_57761086的博客
09-23 2111
讲解C++中list的使用，如构造模块，修改模块，特殊操作模块。展示list的构造，修改，以及排序，去重，删除指定元素，迭代器失效的问题的引出与解决。
C++list容器
weixin_43867777的博客
02-17 231
1、list基本概念 **功能：**将数据进行链式存储 链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成：链表由一系列结点组成 结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域 STL中的链表是一个双向循环链表 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代...
C/C++ — STL中List用法
HiroGuo 的博客
01-21 4581
C/C++ — STL中List用法List 简述List 的使用增加和插入元素List删除元素List排序及合并 List 简述 std::list C++ 容器模版，T类型的双向链表。有序、可以在任意位置插入或删除。无法通过位置来访问元素，必须逐个遍历，可以通过开始元素或者最后一个元素遍历。 List 的使用 生成一个空的list容器： std::list &amp;lt;std::string&amp;gt...
STL设计之链表设计,分块分组件分析,迭代器设计思路
小杰312的博客
03-27 2734
STL设计之链表设计,分块分组件分析,迭代器设计思路
【C++】STL——list的介绍和使用、list增删查改函数的介绍和使用、push_back、pop_back
Crocodile1006的博客
07-25 3512
STL、list的使用、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中的有效元素）
链表的基本操作（代码）
m0_73401427的博客
10-30 98
【代码】链表的基本操作（代码）
STL之四：list用法详解
热门推荐
longshengguoji的专栏
01-19 2万+
list容器介绍 相对于vector容器的连续线性空间，list是一个双向链表，它有一个重要性质：插入操作和删除操作都不会造成原有的list迭代器失效，每次插入或删除一个元素就配置或释放一个元素空间。也就是说，对于任何位置的元素插入或删除，list永远是常数时间。 常用函数 (1)    构造函数 list c:创建一个空的list list c1(c2):复制另一个同类型元素的list
C++ STL list介绍与使用方法
Cypress的博客
12-15 5550
list(链表)链表也即链式表，在数据结构中，我们知道线性表的物理存储结构有两种，顺序表(数组)和链式表(结点)。链表是在堆中为每一个元素分配内存，然后利用指针将所有元素串起来。根据这种物理存储结构，我们很容易明白：链表在插入、删除效率上比较高，但没有办法随机访问，因此访问速度慢。 顺序表在STL中的实现为vector，其优点是元素访问速度快(元素存储在连续的数组中，可以直接通过索引计算元素地址)
c++ stl list
08-16
- *1* *2* *3* [C++——STL之list详解](https://blog.csdn.net/weixin_59055853/article/details/128404113)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

茉莉蜜茶v

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

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

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

打赏作者

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

抵扣说明：

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

余额充值