【C++标准模版库】list的介绍及使用

news2025/1/20 14:51:56

list

  • 一.list的介绍
  • 二.list的使用
    • 1.list 构造函数
    • 2.list 空间大小
    • 3.list 增删查改
    • 4.list 迭代器的使用
      • 1.正向迭代器
      • 2.反向迭代器
    • 5.list 其他成员函数
  • 三.vector与list关于sort性能的比较

一.list的介绍

  C++中的list标准模板库（STL）是C++标准库中的一个重要组成部分，它提供了一种双向链表的数据结构实现。list是C++ STL中的一个序列容器，它允许在常数时间内进行任意位置的插入和删除操作。与vector不同，list是一个双向链表，其元素不是连续存储的，而是存储在互不相关的独立节点中，每个节点都包含数据部分和两个指针（分别指向前一个节点和后一个节点）。

list关键特性：

  1. 双向链表：list的底层实现是双向链表，支持高效的插入和删除操作，尤其是在链表的头部和尾部。
  2. 不支持随机访问：与vector和deque（双向队列）等容器不同，list不支持通过索引直接访问元素，访问特定位置的元素需要从已知位置（如头部或尾部）开始迭代。
  3. 迭代器：list提供了双向迭代器，允许从前往后或从后往前遍历链表。
  4. 内存分配：由于list的元素不是连续存储的，因此它不需要在插入或删除元素时重新分配大块内存，这减少了内存碎片和重新分配的开销。

二.list的使用

  学习list时查看文档是非常重要的（list的文档介绍），list在实际中非常的重要，在实际中我们熟悉常见的接口就可以，下面列出了哪些接口是要重点掌握的。

1.list 构造函数

(construct)构造函数声明接口说明
list()（重点）无参构造
list（size_type n, const value_type& val =value_type()）构造并初始化n个val，无val默认为T()，例如整形为0
list (const list& x)（重点）拷贝构造
list (InputIterator first, InputIterator last)使用迭代器区间进行初始化构造

注意：list使用模板，template < class T > ，其中将T重定义为value_type。

int main()
{
	list<int> l1; //无参构造
	list<int> l2(10, 1); //10个1有参构造
	list<int> l3(l2.begin(), l2.end()); //迭代器区间构造
	list<int> l4(l2); //拷贝构造

	//list<int> l3(l2.begin() + 3, l2.end() - 2); error
	list<int> l5(++l2.begin(), --l2.end()); 
	//注意：list迭代器区间构造不支持+，-操作，但是支持++，--

	//1.迭代器循环遍历
	list<int>::iterator it = l4.begin();
	while (it != l4.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//2.auto+范围for变量
	for (auto e : l4)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

2.list 空间大小

函数声明接口说明
size返回list中有效节点的个数
empty检测list是否为空，是返回true，否则返回false
int main()
{
	list<int> l1;
	cout << l1.size() << endl;  //0
	cout << l1.empty() << endl; //1

	return 0;
}

3.list 增删查改

函数声明接口声明
front返回list的第一个节点中值的引用
back返回list的最后一个节点中值的引用
push_front在list首元素前插入值为val的元素
pop_front删除list中第一个元素
push_back在list尾部插入值为val的元素
pop_back删除list中最后一个元素
assign赋值：支持个数赋值、迭代器赋值（不常用）
insert在list position 位置中插入值为val的元素（只支持迭代器）
erase删除list position位置的元素（只支持迭代器）
swap交换两个list中的元素
resize改变list的有效元素的个数
clear清空list中的有效元素
emplace_front在某些情况下比push_front效率高
emplace_back在某些情况下比push_back效率高
int main()
{
	list<int> l1(10, 1); //初始化为10个1
	l1.front() = 100; //返回引用——>修改头为100
	l1.back() = 100;  //返回引用——>修改尾为100

	l1.push_front(10); //头插
	l1.pop_front();    //头删
	l1.push_back(10);  //尾插
	l1.pop_back();     //尾删

	list<int> l2;
	l2.assign(5, 1); //赋值为5个1
	l2.assign(l1.begin(), l1.end()); //迭代器赋值

	list<int> l3;
	l3.push_back(1);
	l3.push_back(2);
	l3.push_back(3);
	l3.push_back(4);
	//要求在第3个位置插入10：实际是第四个位置变成10
	//错误写法：l3.insert(l3.begin() + 3, 10); 
	//双向迭代器：支持++/--、不支持随机访问+/-

	//正确写法如下：
	auto it = l3.begin();
	int k = 3;
	while (k--)
	{
		++it;
	}
	l3.insert(it, 10); //插入一个10
	for (auto e : l3)
	{
		cout << e << " "; //1 2 3 10 4
	}
	cout << endl;

	l3.insert(it, 5, 1); //插入5个1
	for (auto e : l3)
	{
		cout << e << " "; //1 2 3 10 4
	}
	cout << endl;

	l3.insert(it, l1.begin(), l1.end()); //插入5个1
	for (auto e : l3)
	{
		cout << e << " "; //1 2 3 10 4
	}
	cout << endl;

	int x = 0;
	cin >> x;
	it = find(l3.begin(), l3.end(), x); //先找x所在的迭代器
	if (it != l3.end()) //找不到x的表面：it == l3.end()
	{
		l3.erase(it); //按照迭代器删除x
	}

	l3.swap(l1); //l3与l1交换
	l3.clear();  //清空l3中的有效数据
	l3.resize(10, 1); //修改有效数据的个数：10个数据全为1
	l3.resize(20);    //前10个数据全为1，后10个数据默认为0

	return 0;
}

struct A
{
public:
	A(int a1 = 1, int a2 = 1)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1 = 1, int a2 = 1)" << endl;
	}

	A(const A& a)
	{
		cout << "A(const A& a)" << endl;
	}

	int _a1;
	int _a2;
};
int main()
{
	//对于内置类型无区别
	list<int> l1;
	l1.push_back(1);
	l1.emplace_back(2);

	list<A> l2;
	A aa1(1, 1);
	l2.push_back(aa1);     //尾插有名对象
	l2.push_back(A(2, 2)); //尾插匿名对象
	//l2.push_back(3, 3);  //不支持

	A aa2(1, 1); //有参构造
	l2.emplace_back(aa2); //拷贝构造
	l2.emplace_back(A(2, 2)); //有参构造+拷贝构造

	//emplace_back()支持直接传构造A对象的参数，而push_back()不支持
	l2.emplace_back(3, 3); //直接有参构造更高效

	return 0;
}

在这里插入图片描述

4.list 迭代器的使用

函数声明接口说明
begin + end（重点）获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator/const_reverse_iterator，获取第一个数据前一个位置的reverse_iterator/const_reverse_iterator

迭代器划分为两类：

按照功能：

  1. 正向迭代器：iterator
  2. 反向迭代器：reverse_iterator
  3. const修饰正向迭代器：const_iterator
  4. const修饰反向迭代器：const_reverse_iterator

按照性质：

  1. 单向：forward_list/unordered_map… 支持：++
  2. 双向：list/map/set… 支持：++/–
  3. 随机：vector/string/deque… 支持：++/–/+/-

+：正向、支持随机访问（例如：支持begin()++、begin() + 3）
-：反向、支持随机访问（例如：支持begin()- -、begin() - 3）
++：正向、不支持随机访问（例如：支持begin()++、不支持begin() + 3）
–：反向、不支持随机访问（例如：支持begin()- -、不支持begin() - 3）

双向包含单向，同理随机包含双向。

在这里插入图片描述

int main()
{
	list<int> l1(10, 1);
	//list不支持算法库中的sort，要求随机迭代器
	//sort(l1.begin(), l1.end());

	//vector、string支持sort
	string s1("156874239");
	sort(s1.begin(), s1.end());
	cout << s1 << endl; //123456789

	return 0;
}

1.正向迭代器

在这里插入图片描述

int main()
{
	//普通正向迭代器
	list<int> l1(10, 1);
	list<int>::iterator it = l1.begin();
	while (it != l1.end())
	{
		//(*it)++; 可以修改
		cout << *it << " ";
		++it;
	}
	cout << endl;

	//const修饰正向迭代器
	const list<int> l2(10, 1);
	list<int>::const_iterator cit = l2.begin();
	while (cit != l2.end())
	{
		//(*cit)++; 不可以修改
		cout << *cit << " ";
		++cit;
	}
	cout << endl;

	return 0;
}

2.反向迭代器

在这里插入图片描述

int main()
{
	//普通反向迭代器
	list<int> l1(10, 1);
	list<int>::reverse_iterator rit = l1.rbegin();
	while (rit != l1.rend())
	{
		//(*rit)++; 可以修改
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

	//const修饰反向迭代器
	const list<int> l2(10, 1);
	list<int>::const_reverse_iterator crit = l2.rbegin();
	while (crit != l2.rend())
	{
		//(*crit)++; 不可以修改
		cout << *crit << " ";
		++crit;
	}
	cout << endl;

	return 0;
}

5.list 其他成员函数

函数声明接口声明
reverse逆置设计的些许冗余，可以使用算法库中的reverse
sort排序：默认得到升序的list，降序需要使用仿函数
merge合并两个有序的list，默认传入升序的list，得到升序的list，降序需要使用仿函数
unique将有序的list去除重复的数据
remove移除给定值的数据
splice剪切+粘贴（具体看如下代码）
int main()
{
	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);

	//list的成员函数reverse设计的有些冗余
	l1.reverse();
	//算法库的reverse
	reverse(l1.begin(), l1.end());

	l1.sort(); //排序：默认升序，低层是归并
	//算法库的函数sort要支持随机访问，无法被list使用，低层是快排

	//降序——>仿函数
	less<int> ls;    //小于号：升序
	greater<int> gt; //大于号：降序

	l1.sort(ls);

	l1.sort(greater<int>()); //匿名对象

	list<int> first;
	first.push_back(1);
	first.push_back(3);
	first.push_back(5);

	list<int> second;
	second.push_back(2);
	second.push_back(4);
	second.push_back(6);

	//合并两个升序list，得到升序的list，此时second为空
	//也支持合并两个降序list，得到降序的list——>与sort一样使用仿函数
	first.merge(second); 
	cout << first.size() << endl;  //6
	cout << second.size() << endl; //0

	list<int> l2;
	l2.push_back(1);
	l2.push_back(3);
	l2.push_back(2);
	l2.push_back(2);
	l2.push_back(5);
	l2.push_back(5);
	l2.sort();    //先排序再去重
	l2.unique();  //有序list去重
	l2.remove(3); //移除3

	return 0;
}

int main()
{
	list<int> mylist1, mylist2;
	for (int i = 1; i <= 4; ++i)
	{ 
		mylist1.push_back(i);      //mylist1: 1 2 3 4
	}
	for (int i = 1; i <= 3; ++i)
	{
		mylist2.push_back(i * 10); //mylist2: 10 20 30
	}

	list<int>::iterator it;
	it = mylist1.begin();
	++it;

	//一个链表的节点转移给另一个链表
	mylist1.splice(it, mylist2); //mylist1：1 10 20 30 2 3 4
                                 //mylist2：empty

	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	l1.push_back(5);
	l1.push_back(6);

	int x;
	cin >> x;
	it = find(l1.begin(), l1.end(), x);
	if (it != l1.end())
	{
		//l1.splice(l1.begin(), l1, it); //将it位置的数据剪切粘贴到l1的头部
		
		//将迭代器区间it~l1.end()剪切粘贴到l1的头部
		l1.splice(l1.begin(), l1, it, l1.end()); 
	}

	return 0;
}

三.vector与list关于sort性能的比较

注意：凡是测试性能Debug下不具有参考价值，要在release下测试性能。

int main()
{
	srand(time(0));
	const int N = 1000000;

	list<int> l1;
	vector<int> v1;
	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i; //减少重复的数值
		l1.push_back(e);
		v1.push_back(e);
	}

	int begin1 = clock();
	sort(v1.begin(), v1.end()); //算法库：sort（快排）排序vector
	int end1 = clock();

	int begin2 = clock();
	l1.sort(); //无法使用算法库的sort，使用类成员函数sort（归并）排序
	int end2 = clock();

	printf("vector sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);

	return 0;
}

在这里插入图片描述

思考：可以发现算法库中的sotr性能更高，list中成员函数sort性能不太高，因此如果将list中的数据拷贝到vector中进行sort，再将vector赋值到list时性能还会更高？代码如下：

int main()
{
	srand(time(0));
	const int N = 1000000;

	list<int> lt1;
	list<int> lt2;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i;
		lt1.push_back(e);
		lt2.push_back(e);
	}

	int begin1 = clock();
	//拷贝vector
	vector<int> v(lt2.begin(), lt2.end());

	//排序
	sort(v.begin(), v.end());

	//拷贝回lt2
	lt2.assign(v.begin(), v.end());

	int end1 = clock();

	int begin2 = clock();
	lt1.sort();
	int end2 = clock();

	printf("list copy vector sort copy list sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

在这里插入图片描述

事实证明：拷贝数据不会花太多时间，以及list排序性能不太行，甚至不如拷贝到vector中进行排序。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1978737.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux文件管理和IO重定向知识总结

Linux文件管理和IO重定向知识总结

目录 一&#xff0c;文件管理 Linux的目录结构是一个树状结构&#xff1a; 文件的分类&#xff1a; 操作文件的常用命令&#xff1a; 文件元数据和节点和inode表结构&#xff1a; 特点&#xff1a; 创建文件&#xff1a; 查看文件inode号&#xff1a; cp和inode&#x…
阅读更多...
揭秘Matplotlib等高线图：让数据‘高山流水‘间，笑点与深度并存！

揭秘Matplotlib等高线图：让数据‘高山流水‘间，笑点与深度并存！

1. 引言 在这个数据如山的时代&#xff0c;你是不是也曾在茫茫数海中迷失方向&#xff0c;渴望找到那片隐藏的“数据绿洲”&#xff1f;别怕&#xff0c;今天咱们就来聊聊Matplotlib这位绘图界的魔术师&#xff0c;特别是它那令人叹为观止的等高线图技能。想象一下&#xff0c…
阅读更多...
领域模型(Domain Model)

领域模型(Domain Model)

前言 软件的核心是其为用户解决领域相关的问题的能力。所有其他特性&#xff0c;不管有多么重要&#xff0c;都要服务于这个基本目的。当领域很复杂时&#xff0c;这是一项艰巨的任务&#xff0c;要求高水平技术人员的共同努力。开发人员必须钻研领域以获取业务知识。他们必须…
阅读更多...
拉刀基础知识——拉刀的种类

拉刀基础知识——拉刀的种类

如前面所说&#xff1a;近期要围绕拉削和拉刀这个话题&#xff0c;分享一些相关的内容&#xff0c;从最基础的知识开始&#xff0c;为此还专门买了本旧书——《拉刀设计》入门学习。废话不多说&#xff0c;直接开始。 拉刀最早由冲头演变而来&#xff0c;用于加工方孔&#xf…
阅读更多...
【Web】TFCCTF 2024 部分题解

【Web】TFCCTF 2024 部分题解

目录 GREETINGS SURFING SAFE_CONTENT FLASK DESTROYER GREETINGS 打express的SSTI GitHub - TheWation/NodeJsSSTI: Express app with Pug templates demonstrating SSTI vulnerability and secure implementation for educational purposes. payload: /result?user…
阅读更多...
历史标签如何时间迁移？

历史标签如何时间迁移？

本文解析的论文是&#xff1a; Lin, C.; Du, P.; Samat, A.; Li, E.; Wang, X.; Xia, J. Automatic Updating of Land Cover Maps in Rapidly Urbanizing Regions by Relational Knowledge Transferring from GlobeLand30. Remote Sens. 2019, 11, 1397. https://doi.org/10.33…
阅读更多...
一刷代码随想录（动态规划2）

一刷代码随想录（动态规划2）

62.不同路径 题意&#xff1a; 一个机器人位于一个 m x n 网格的左上角 &#xff08;起始点在下图中标记为 “Start” &#xff09;。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角&#xff08;在下图中标记为 “Finish” &#xff09;。 问总共有多少…
阅读更多...
我的面包多

我的面包多

我的面包多主页&#xff1a;https://mbd.pub/o/author-bGubnGpq 欢迎咨询。
阅读更多...
JavaSE面试篇章——一文干破Java集合

JavaSE面试篇章——一文干破Java集合

文章目录 Java集合——一文干破集合一、集合的理解和好处1.1 数组1.2 集合 二、集合的框架体系三、Collection接口和常用方法3.1 Collection接口实现类的特点3.2 Collection接口遍历元素方式1-使用Iterator(迭代器)3.2.1 基本介绍3.2.2 迭代器的执行原理3.2.3 Iterator接口的方…
阅读更多...
数据库典型例题2-ER图转换关系模型

数据库典型例题2-ER图转换关系模型

1.question solution: 2.做题步骤 一些解释&#xff1a; <1弱实体把强属性的主键写进去&#xff0c;指向强属性。eg:E6_A13指向E5_A13 <21:1&#xff0c;1:n&#xff0c;m:n&#xff1a;将完全参与的一方&#xff08;双线&#xff09;指向另一方&#xff0c;并将对方的…
阅读更多...
AutoCAD ObjectArx二次开发(三) 创建MFC界面

AutoCAD ObjectArx二次开发(三) 创建MFC界面

主题&#xff1a;本章节主要介绍在ObjectARX项目中如何使用MFC界面进行交互操作&#xff0c;具体采用模态对话框的形式。 一、创建MFC的对话框 在项目中添加新项&#xff0c;选择MFC类&#xff0c;点击确定按钮&#xff0c;如下图所示。 然后会出现下图界面&#xff0c;填写类…
阅读更多...
苹果应用程序清理卸载工具：App Cleaner Uninstaller Pro for Mac

苹果应用程序清理卸载工具：App Cleaner Uninstaller Pro for Mac

App Cleaner & Uninstaller Pro 是一款专为 Mac OS X 操作系统设计的应用程序清理和卸载工具。这款软件的主要功能是帮助用户彻底删除不需要的应用程序、插件和残留文件&#xff0c;从而释放磁盘空间并提高系统性能。 特点和优势&#xff1a; 彻底卸载应用程序&#xff1a;…
阅读更多...
【软件设计书】详细设计说明书和概要设计说明书（Word原件直接套用）

【软件设计书】详细设计说明书和概要设计说明书（Word原件直接套用）

系统详细设计说明书案例&#xff08;直接套用&#xff09; 1.系统总体设计 2.性能设计 3.系统功能模块详细设计 4.数据库设计 5.接口设计 6.系统出错处理设计 7.系统处理规定 软件开发全文档下载&#xff08;下面链接或者本文末个人名片直接获取)&#xff1a;本文末个人名片直接…
阅读更多...
【C语言】文件操作（下）

【C语言】文件操作（下）

文章目录 前言1. 文件的读和写2. 文件的顺序读写2.1 顺序读写函数的介绍2.1.1 fgetc 和 fputc2.1.2 fgets 和 fputs 3. 文件缓冲区4. 总结 前言 在之前文件操作&#xff08;上&#xff09;和文件操作&#xff08;中&#xff09;的文章中&#xff0c;我从为什么要使用文件再到文…
阅读更多...
RabbitMQ高级特性 - 生产者消息确认机制

RabbitMQ高级特性 - 生产者消息确认机制

文章目录 生产者消息确认机制概述confirm 代码实现return 代码实现 生产者消息确认机制 概述 为了保证信息 从生产者 发送到 队列&#xff0c;因此引入了生产者的消息确认机制. RabbitMQ 提供了两种解决方案&#xff1a; 通过事务机制实现.通过发送确认机制&#xff08;confi…
阅读更多...
CPU利用率100%该怎么办

CPU利用率100%该怎么办

1 节拍率 Linux 作为一个多任务操作系统&#xff0c;将每个 CPU 的时间划分为很短的时间片&#xff0c;再通过调度器轮流分配给各个任务使用&#xff0c;因此造成多任务同时运行的错觉。 为了维护 CPU 时间&#xff0c;Linux 通过事先定义的节拍率&#xff08;内核中表示为 H…
阅读更多...
AI大模型定级体系

AI大模型定级体系

前言&#xff1a;一直以来人们对通用人工智能&#xff08;AGI&#xff09;的定义始终缺乏一个具体的衡量标准&#xff0c;而现在OpenAI已创建了一套分级系统。 AI大模型定级 OpenAI对于其大模型的定级有一个独特的分级体系&#xff0c;旨在描述其人工智能系统的发展阶段以及距…
阅读更多...
网络安全埋头干活，也要抬头看路

网络安全埋头干活，也要抬头看路

24年的Hvv大家干的正是热火朝天&#xff0c;也有的干的无可奈何&#xff0c;确实Hvv的核心其实是在Hvv前的准备阶段&#xff0c;Hvv中可能更多的是盯监控。 7月份我也出了两趟差&#xff0c;看了一下在Hvv项目上的小伙伴&#xff0c;30%的时间是在处理误报&#xff0c;60%的时…
阅读更多...
51 for 循环与 while 循环

51 for 循环与 while 循环

Python 主要有 for 循环和 while 循环两种形式的循环结构&#xff0c;多个循环可以嵌套使用&#xff0c;并且还经常和选择结构嵌套使用来实现复杂的业务逻辑。 while 循环一般用于循环次数难以提前确定的情况&#xff0c;当然也可以用于循环次数确定的情况。 for 循环一般用于…
阅读更多...
共享`pexlinux`数据文件的网络服务

共享`pexlinux`数据文件的网络服务

实验环境准备&#xff1a; 1.红帽7主机 2.要全图形安装 3.配置网络为手动&#xff0c;配置网络可用 4.关闭vmware DHCP功能 一、kickstart自动安装脚本制作 1.安装图形化生成kickstart自动脚本安装工具 2.启动图形制作工具 3.图形配置脚本 这里使用的共享方式是http&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023