【C++】介绍STL中list容器的常用接口

已于 2024-07-15 10:38:55 修改
阅读量1.3k 收藏 21
点赞数 28
分类专栏： C++ 文章标签： c++ 笔记 学习 stl list
于 2024-01-24 23:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80909286/article/details/135830212
版权

目录

一、STL中的list简介

二、构造函数

2.1 默认构造函数

2.2 填充构造（用n个相同的值构造）

2.3 迭代器构造 

2.4 拷贝构造和赋值运算符重载 

三、迭代器

3.1 正向迭代器

3.2 反向迭代器

四、容量相关 

4.1 获取list中有效数据的个数

4.2 判断list是否为空 —— empty

五、元素访问

5.1 获取第一个有效节点的数据

5.2 获取最后一个有效节点的数据

六、修改相关

6.1 头插、尾插 —— push_front、push_back

6.2 尾插、尾删 —— pop_front、pop_back 

6.3 在任意位置插入

6.4 在任意位置删除 —— erase

6.5 交换两个list对象

6.6 清空list中的有效节点

七、链表操作

7.1 将一个list上的数据转移到另一个list —— splice

7.2 删除某个特定数据

7.3 给数据排序 —— sort

7.4 去除重复数据 —— unique

7.5 反转数据 —— reverse

八、list与vector的对比 

一、STL中的list简介

1. list是可以在常数时间(O(1))内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

2. list与forward_list非常相似，最主要的不同在于forward_list是单链表，只能向前迭代，这让forward_list更简单高效。

3. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

4. 与其他的序列式容器(array，vector等)相比，list通常在任意位置进行插入、移除元素的执行效率更好。

5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，必须从已知的位置(比如头部或者尾部)迭代到目标位置，而迭代到目标位置需要线性的时间(O(n))开销；除此之外list还需要一些额外的空间，以保存每个节点的相关联系。

【文档描述】

二、构造函数

2.1 默认构造函数

【代码演示】

#include <iostream>
#include <list>
#include <string>
using namespace std;

int main()
{
	//默认拷贝拷贝构造 list<T> lt;(T为list存储的数据类型)
	list<string> ls;

	return 0;
}

【输出结果】

        注：list不像string和vector，list没有容量capacity这个属性。 

2.2 填充构造（用n个相同的值构造）

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	//填充构造    list (size_type n, const value_type& val = value_type())

	list<int> li(5, 20);

	//如果不指定val的值就会初始化为相应类型的默认值
	//int为0 double为0.0 char为'\0'……
	list<double> ld(3);

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	for (const auto& k : ld)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

2.3 迭代器构造 

【代码演示】

#include <iostream>
#include <list>
#include <string>
using namespace std;

int main()
{
	//迭代器构造 list (InputIterator first, InputIterator last) 
    //迭代器区间为左闭右开 -》 [first, last)

	//用数组构造
	int array[] = { 1,2,3,4,5,6 };
	list<int> li(array, array + sizeof(array) / sizeof(array[0]));

	//这个其实是先用数组构造了一个list<int> temp 
    //然后用拷贝构造将temp拷贝给了li_another -》 list<int> li_another(temp)
	list<int> li_another{ 1,2,3,4,5 };

	//可以用别的容器的迭代器来构造list
	string s("Hello list!");
	list<char> lc(s.begin(), s.end());

	//可以用list的迭代器来构造list
	list<char> lc_copy(++lc.begin(), --lc.end());

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	for (const auto& k : li_another)
	{
		cout << k << " ";
	}
	cout << endl;

	for (const auto& k : lc)
	{
		cout << k;
	}
	cout << endl;

	for (const auto& k : lc_copy)
	{
		cout << k;
	}
	cout << endl;
	return 0;
}

【输出结果】

2.4 拷贝构造和赋值运算符重载 

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	//拷贝构造 list (const list& x)
    //赋值运算符重载 list& operator=(const list& x)

	list<int> li{ 1,2,3,4,5 };

	//拷贝构造
	list<int> li_copy(li);

	//赋值运算符重载
	list<int> li_another = li;

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;	

	for (const auto& k : li_copy)
	{
		cout << k << " ";
	}
	cout << endl;

	for (const auto& k : li_another)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】 

三、迭代器

【示意图】

3.1 正向迭代器

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5 };
	cout << *li.begin() << endl;
	cout << *(--li.end()) << endl;

	return 0;
}

        list的迭代器不能直接使用加法或减法（如+1或-1）来实现迭代器位置的更换，因为list的各个节点并不在一块连续的空间，如果直接通过加减法来实现迭代器位置的更换会造成非法访问。所以我们需要使用重载过后的前置或后置的加加、减减操作符来实现迭代器位置的变更。

 【输出结果】

3.2 反向迭代器

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5,6,7 };
	list<int>::reverse_iterator rbit = li.rbegin();
	while (rbit != li.rend())
	{
		//从begin到end 从rbegin到rend都是++
		cout << *rbit << " ";
		++rbit;
	}
	cout << endl;
	return 0;
}

【输出结果】

四、容量相关 

4.1 获取list中有效数据的个数

【代码演示】

#include <iostream>
#include <list>
#include <string>
using namespace std;

int main()
{
	list<string> ls{ "Hello", "lisr", "and", "string", "!" };
	cout << ls.size() << endl;
	return 0;
}

【输出结果】 

4.2 判断list是否为空 —— empty

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li;
	cout << li.empty() << endl;

	//尾插一个1
	li.push_back(1);

	cout << li.empty() << endl;
	return 0;
}

【输出结果】

五、元素访问

5.1 获取第一个有效节点的数据

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5,6 };
	cout << li.front() << endl;

	return 0;
}

【输出结果】

5.2 获取最后一个有效节点的数据

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<string> ls{ "Hello", "list!" };
	cout << ls.back() << endl;

	return 0;
}

【输出结果】

六、修改相关

6.1 头插、尾插 —— push_front、push_back

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 2,3,4,5 };

	//头插1
	li.push_front(1);

	//尾插6
	li.push_back(6);

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

【输出结果】

6.2 尾插、尾删 —— pop_front、pop_back 

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5,6 };
	//头删
	li.pop_front();

	//尾删
	li.pop_back();

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

【输出结果】

6.3 在任意位置插入

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,5,6,7 };

	list<int>::iterator pos = li.begin();

	//list的迭代器不支持直接加减一个值。
    //比如我们要在5的前面插入一个4，就必须让pos++3次，而不能pos + 3
	//循环的次数可以看成目标位置下标的数值，但不是真正的下标
    //因为list节点并不分布在一块连续的空间
	for (int i = 0; i < 3; ++i)
	{
		++pos;
	}

	li.insert(pos, 4);

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

        list的插入操作不像vector的插入操作，在插入数据中如果进行了扩容，vector会发生迭代器失效，而list不会。这是因为vector的扩容是开辟一块更大的空间，将原空间数据拷贝到新空间后再释放原空间，而迭代器pos任然指向旧空间，这样就会对非法空间进行访问。但是list的扩容只是开辟一块空间来存储新的数据，其他数据的位置和关系并不会发生变化，所以并不会发生迭代器失效。

6.4 在任意位置删除 —— erase

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5,6,7,8 };
	list<int>::iterator pos = li.begin();

	//删除list中的所有偶数
	while (pos != li.end())
	{
        //避免发生迭代器失效
		if (*pos % 2 == 0)
		{
			pos = li.erase(pos);
		}
		else
		{
			++pos;
		}
	}

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

        虽然list在插入过程中不会发生迭代器失效，但是在删除过程中任然会发生迭代器失效。为了避免这种情况我们就需要利用erase的返回值

        erase的返回值是一个指向被删除数据的下一个数据的迭代器，我们在执行删除操作之后让迭代器pos等于erase的返回值，如果没有执行就正常++，这样就能避免迭代器失效问题了。

6.5 交换两个list对象

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li1{ 1, 2, 3, 4 ,5 };
	list<int> li2{ 6, 7, 8 ,9, 10 };

	li1.swap(li2);

	cout << "li1的数据为：";
	for (const auto& k : li1)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "li2的数据为：";
	for (const auto& k : li2)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

6.6 清空list中的有效节点

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5 };
	cout << "clear前的数据为：";
	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	li.clear();
	cout << "clear后的数据为：";
	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

七、链表操作

7.1 将一个list上的数据转移到另一个list —— splice

【函数原型】

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> des1{ 1,2,3,4,5 };
	list<int> des2(des1);
	list<int> des3 = des2;

	list<int> sour1{ 6,7,8,9,10 };
	list<int> sour2(sour1);
	list<int> sour3 = sour2;

	//转移一整个链表
	des1.splice(des1.end(), sour1);

	//转移一个元素
	des2.splice(des2.end(), sour2, sour2.begin());

	//转移一个区间 -》左闭右开
	des3.splice(des3.end(), sour3, ++sour3.begin(), --sour3.end());

	cout << "des1的数据为：";
	for (const auto& k : des1)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "sour1的数据为：";
	for (const auto& k : sour1)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "des2的数据为：";
	for (const auto& k : des2)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "sour2的数据为：";
	for (const auto& k : sour2)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "des3的数据为：";
	for (const auto& k : des3)
	{
		cout << k << " ";
	}
	cout << endl;

	cout << "sour3的数据为：";
	for (const auto& k : sour3)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

7.2 删除某个特定数据

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,1,1,5,8,5,4,3 };
	cout << "remove前的数据为：";
	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	li.remove(1);
	cout << "remove后的数据为：";
	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

【输出结果】

7.3 给数据排序 —— sort

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 32,5,86,12,6,2 };
    
    //list排序通过归并排序实现
	li.sort();
	for (auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

【输出结果】

         注：list用不了algorithm算法库中的sort，因为algorithm的sort的参数要求是随机迭代器RandomAccessIterator，而list的迭代器是双向迭代器bidirectional iterator。

        除了随机迭代器RandomAccessIterator和双向迭代器bidirectional iterator外还有一种迭代器类型是InputIterator，这个迭代器类型就是只要是迭代器就行。

        不过话虽如此，但并不建议对list进行排序，因为list的数据在空间上是分散开的，并不适合排序，list排序的效率远远不及vector这种在连续空间上储存数据的容器，因此并不建议对list进行排序。

7.4 去除重复数据 —— unique

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,4,6,4,6,7,8,9,1,3,5 };

	//在去重之前建议先对list进行排序 不然效率实在是太低了 不过排序的效率也很低就是了
	li.sort();
	li.unique();

	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;
	return 0;
}

【输出结果】

7.5 反转数据 —— reverse

【代码演示】

#include <iostream>
#include <list>
using namespace std;

int main()
{
	list<int> li{ 1,2,3,4,5,6 };

	li.reverse();
	for (const auto& k : li)
	{
		cout << k << " ";
	}
	cout << endl;

	return 0;
}

【输出结果】

八、list与vector的对比 

vectorlist
底 层 结 构动态顺序表，一段连续空间带头结点的双向循环链表
随 机 访 问支持随机访问，访问某个元素时间复杂度为O(1)不支持随机访问，访问某个元素时间复杂度为O(N)
插 入 和 删 除任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容；增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不需要搬移元素，时间复杂度为 O(1)
空 间 利 用 率底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低， 缓存利用率低
迭 代 器原生态指针对原生态指针(节点指针)进行封装
迭 代 器 失 效在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效；删除时，当前迭代器需要重新赋值否则会失效插入元素不会导致迭代器失效， 删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使 用 场 景需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随机访问

kazamata
关注
专栏目录
【C++基础知识】list常用接口
weixin_43962381的博客
04-03 458
文章目录list简介list的构造接口list的迭代器list的插入接口list的删除接口swaplist capacityfront和back list简介 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。 与
C++——STL之list详解
weixin_59055853的博客
12-22 1469
list是一个序列容器，支持常数时间（也就是O(1)）内进行任意位置的插入删除，还支持双向迭代。list容器作为双向链表实现;双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。与其他基本标准序列容器（array, vector and deque）相比，list在容器内已经获得迭代器的任何位置插入、提取和移动元素时通常表现更好，因此在大量使用这些元素的算法中也是如此，例如排序算法。与其他序列容器相比，主要缺点是它们无法通过其位置直接访问元素;
【C++】STL——vector的常用接口
m0_64224788的博客
11-30 1045
vector是stl中非常重要的容器，相当于数据结构中的顺序表，我们今天来学习它的常用接口。
STL中的list以及简单实现
最新发布
Small_entreprene的博客
08-07 955
说到迭代器遍历的话，与string，vector都一样；
C++ STL list
XXXTENTAC1ON的博客
04-20 461
Listlist 的介绍list 的使用list 的创建访问、push_front、erase、unique、removelist 与 vector 的区别总结 list 的介绍 list是序列容器，允许在序列中的任何位置执行固定O(1)时间的插入和删除操作，并在两个方向上进行迭代 list容器使用双链表实现，双链表将每个元素存储在不同的存储位置，每个节点通过next，prev指针链接成顺序表 list与其他基本标准序列容器（array、vector和deque）相比，list通常在容器内的任何位置插入、
C++——STL容器——List
XLZ_44847的博客
05-16 1190
为了实现迭代器正常功能所以将迭代器用类模板进行了封装，又为了const考虑增加两个模板参数来控制。it1->c1;//it1实际的类型是ListIterator，成员是ListNode的结构体指针，这个结构体是链表的结点，包含成员前序、后继指针和值//it1的构造函数将ListNode*类型的参数赋值给it1下的成员（链表结点指针），使用的是lt1调用的begin，返回值是ListIterator类型，其中的结点是头结点的下一个结点。
深入解析C++ STL中的常用容器
12-31
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。 1、顺序性容器 （1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。...
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++】STL容器之list
DanteKing的博客
02-08 1298
stl之list的详解和模拟实现
C++ STL List详解与使用方法
qq_44800780的博客
12-17 779
结构模型 可以看到是一个双向串列的结构。 头文件<List> List的能力 Lits对象自身提供了两个指针，用来指向第一个和最末一个元素，每个元素都有指针指向前一个和下一个元素，下面是List追加一个元素时的内部结构变化： 与array、vector、deque不同的几个主要方面： 1.不支持随机访问，如果你要访问第五个元素，就得顺着串联一个个爬过前4给元素. list中随机访问...
【C++入门到精通】C++入门 —— list (STL)
Yawesh的博客
08-14 2615
本文首先介绍了list的概念和特点。list是C++中的容器之一，采用双向链表存储元素，可以在O(1)时间内插入和删除操作，但访问效率较低。接下来，文章详细探讨了list的使用方式。包括如何构造list对象，并介绍了常见的操作方法，如增加、删除、查找和修改list中的元素。最后，文章进行了list与vector的对比。分析了它们在数据存储方式、动态性、访问效率、插入和删除操作以及内存使用等方面的差异。这有助于读者根据实际需求选择合适的容器。通过本文，读者可以深入了解list的特性和用法，以及与其
c++ stl list总结
11-04
c++ stl list总结
【C++】-- STL之list详解
局部变量和全局变量
06-06 1718
list有如下特征：（1）优点：可在任意位置插入删除元素，插入删除元素效率高（2）底层是双向链表，因此list可以前后双向迭代，通过指针连接前后节点。forward_list是单链表，只能向前迭代（3）缺点：不支持任意位置随机访问；需要额外空间保存前后节点信息......
C++之STL的list用法总结
不积跬步，无以至千里
05-15 2428
list概述vector是连续空间，是基于数组的。list是基于链表的，STL的list是双向循环链表。list的元素操作::push_front(const T& x);//插入一个节点，并作为头结点 ::push_back(const T& x);//插入一个尾节点 iterator ::erase(iterator position);//移除迭代器所指的节点 ::pop_front();//
【C++STL基础入门】list基本使用
m0_62599305的博客
10-13 1754
STL（Standard Template Library）是C++标准库的一个重要组成部分，提供了一套丰富的数据结构和算法，可以大大简化C++程序的开发过程。其中，list容器是STL提供的一种双向链表实现的数据结构，具有高效的插入和删除操作，适用于需要频繁插入和删除元素的场景。本文将介绍list容器的基本使用方法，包括头文件的引入、定义和构造函数、属性函数以及运算符和算法的示例代码。STL（标准模板库）的list是C++中的一种数据结构，用于存储和操作链表。
STL系列之list的常见功能使用
STONE的专栏
11-27 361
STL系列之list的常见功能使用 list是一个双向循环链表，双链表既可以向前又可以向后链接它的元素。 list将元素按顺序储存在链表中. 与向量(vector)相比, 它允许快速的插入和删除，但是随机访问却比较慢。 1)、如何定义一个list对象 #include//在使用list时必须包含头文件#include intmain (void) {  list cList; //
STL中list的使用及其模拟实现
weixin_45897952的博客
04-28 1088
目录 1.STL中的list的底层结构 2.list的使用 2.1构造对象： 2.2链表的遍历方式： 2.3链表的操作（在链表中是没有扩容操作的，因为是链表数据结构，所以直接插入元素就可以了） 1.resize() 2.clear()清空链表 3.front()&&back()（获取首/尾元素可以直接对其进行更改） 4.插入和删除元素 3.list的模拟实现： 1.STL中的list的底层结构 STL...
c++ STL list
菜鸟的自我提升
07-24 636
list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 使用list容器之前必须加上STL的list容器的头文件：#include; list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using namespace ...
C++ STL 容器list详解：插入、删除与操作
"这篇资料主要涵盖了C++ STL容器list的总结，包括其特点、操作方法以及一些常用成员函数的介绍。" 在C++编程中，STL（Standard Template Library，标准模板库）提供了多种容器来存储和管理数据，其中`std::list`是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值