C++中list容器的特性及使用介绍(超详细！！)

最新推荐文章于 2024-09-11 09:33:21 发布

c code

最新推荐文章于 2024-09-11 09:33:21 发布

阅读量819

点赞数 12

文章标签： c++ 开发语言 list

本文链接：https://blog.csdn.net/kk6kk/article/details/138566700

版权

1、list的介绍及使用

1.1 list的介绍

list文档链接： https://cplusplus.com/reference/list/list/?kw=list

注：C++库里自带的list是带头双向循环链表

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

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

3. list与forward_list(单向链表)非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。

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

5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问(list不再支持[]访问)。比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)。

补充：list就没有reserve这个函数了(resize、reserve就 string 和 vector 用的多)

1.2 list的一些接口使用举例

void test_list()
{
	std::list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);

	std::list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		std::cout << *it << " ";
	}
	std::cout << std::endl;

	for (auto e : lt)
	{
		std::cout << e << " ";
	}
	std::cout << std::endl;

	std::list<int>::iterator pos = find(lt.begin(), lt.end(), 3);
	if (pos != lt.end())
	{
		lt.insert(pos, 30);
	}
}

void test_sort()
{
	list<int> lt;
	lt.push_back(10);
	lt.push_back(2);
	lt.push_back(5);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(4);
	lt.push_back(6);
	lt.push_back(4);
	lt.push_back(0);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	//补充一个问题：为什么算法库里已经有了一个sort，list里面还要提供一个sort呢？
	//  答：因为 list 用不了算法库里的那个sort(迭代器的类型不行)
	//虽然：库里的sort是一个模板函数，根据模板的语法，它应该可以接收任何类型的参数
	//但是：实际上其内部使用迭代器时对迭代器是有要求的，其模板参数的名字就暗示了你要传一个随机迭代器
	//  注：即使这边的迭代器的问题解决了，list 也用不了这个算法库里的sort，
	//因为：sort的底层用的是快排，快排有个三数取中，list根本不好定位那个中的位置
	//迭代器功能分类
	//1、单向  ++  //ex：单向链表(forward_list)的迭代器
	//2、双向  ++  --  //ex：list的迭代器
	//3、随机  ++  --  +  -  //ex：vector和string的迭代器
	//注：要求传随机迭代器就只能传随机迭代器，但要求传双向迭代器，你可以传随机迭代器，也可以传双向迭代器(其他类型同理)
	//sort(lt.begin(), lt.end());
	lt.sort(); //默认排升序，想要改成降序，需要用到仿函数 //链表的sort底层是一个归并排序
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	//注：实际上这个链表的sort也不是很常用，因为它的性能不行，效率低
}

void test_op() //性能测试
{
	srand(time(0));
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);

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

	//将list的数据拷贝到vector中进行排序，排序完以后再拷贝回原来的list都比list直接排序来的快，而且快很多
	int begin1 = clock();
	for (auto e : lt1)
	{
		v.push_back(e);
	}
	sort(v.begin(), v.end());
	size_t i = 0;
	for (auto& e : lt1)
	{
		e = v[i++];
	}
	int end1 = clock();

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

	printf("vector sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
	//总结：从这里就能明白，实际中基本不会去用list自己的sort，太慢了
	//原因：list访问数据的效率不如vector
}

void test_merge()
{
	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	l1.push_back(5);

	list<int> l2;
	l2.push_back(6);
	l2.push_back(7);
	l2.push_back(8);
	l2.push_back(9);
	l2.push_back(10);

	l1.merge(l2); //就是将l1和l2合并，不过有个前提，就是l1，l2得先有序
	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;

	for (auto l : l2) //合并之后l2的里面就为空了
	{
		cout << l << " ";
	}
	cout << endl;
}

void test_unique()
{
	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(2);
	l1.push_back(4);
	l1.push_back(3);
	l1.push_back(5);
	l1.push_back(3);

	l1.unique(); //就是去重
	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;
}

void test_remove()
{
	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	l1.push_back(5);

	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;

	l1.remove(2); //指定去删除哪一个值，就等于 find + erase
	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;
}

void test_splice() //splice英文翻译：粘接
//该函数说白了就是起一个转移的效果
{
	list<int> l1;
	l1.push_back(1);
	l1.push_back(2);
	l1.push_back(3);
	l1.push_back(4);
	l1.push_back(5);

	l1.splice(l1.end(),l1, l1.begin()); //这句代码就是l1把自己的的头部结点转移到尾部结点(哨兵位结点)之前
	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;

	list<int> l2;
	l2.push_back(10);
	l2.push_back(20);
	l2.push_back(30);
	l2.push_back(40);
	l2.push_back(50);

	l1.splice(l1.begin(), l2); //这句代码就是l1把l2全部结点转移到自己的头部节点之前(这有个前提要求就是两个链表的结点类型要一样)
	for (auto l : l1)
	{
		cout << l << " ";
	}
	cout << endl;
	for (auto l : l2) //注意：l2被转移之后，l2里就没有结点了
	{
		cout << l << " ";
	}
	cout << endl;

	list<int> l3;
	l3.push_back(6);
	l3.push_back(7);
	l3.push_back(8);
	l3.push_back(9);
	l3.push_back(10);
	
	l1.splice(l1.begin(), l3, l3.begin(), l3.end()); //还可以把其他链表的一部分转移到另一个链表中
}

int main()
{
	test_list();
	test_sort();
	test_op(); //性能测试
	test_merge();
	test_unique();
	test_remove();
	test_splice();
	return 0;
}

1.3 list的迭代器失效（补充）

补充：只要迭代器所指向的结点已经不是原来的结点或者原来的结点被干掉了，都可以认为该迭代器失效了。

此处我们可将迭代器暂时理解成类似于指针。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

2、list的模拟实现

内容太多了，我另外写成了一篇博客，下面是链接。

http://t.csdnimg.cn/w1252 （list的模拟实现）

2.1 list的反向迭代器（补充）

通过前面例子知道，反向迭代器的++就是正向迭代器的--，反向迭代器的--就是正向迭代器的++，因此反向迭代器的实现可以借助正向迭代器，即：反向迭代器内部可以包含一个正向迭代器，对正向迭代器的接口进行包装即可。

反向迭代器的模拟实现：

//在C++中，每一种容器的反向迭代器(如果有迭代器的话)并不是都单独去写了一种放在了那个容器中，而是统一的做了一个反向迭代器的模板。
//也就是 (迭代器)适配器。
//它会根据被传过来的容器的迭代器来相应的去生成对应的反向迭代器。

//这里模拟一下大致的底层原理。

//注意：这个只是模拟，跟库里的不太一样
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
	typedef ReverseIterator<Iterator, Ref, Ptr> Self;

	Iterator _it;

	ReverseIterator(Iterator it) //根据传过来的迭代器来进行构造
		:_it(it)
	{}

	Ref operator*()
	{
		//return *_it; //库里的*并不是这样做的
		
		//而是这样
		Iterator tmp = _it;
		return *(--tmp);
		//原因是：库里的rbegin，用的是原本迭代器的end(也就是哨兵位)去构造的，直接 *_it 得到的是哨兵位里存的数据，这不就跟我们想要的不一致了
		//        库里的rend，用的是原本迭代器的begin(也就是哨兵位的后一个结点，第一个有效结点)去构造的
		//那为什么库里不选择：用原本迭代器的--end(也就是哨兵位的前一个结点，最后一个有效结点)去构造rbegin
		//                    用原本迭代器的end(也就是哨兵位)去构造rend
		//库里这样做的原因是：为了能够跟原本迭代器的 begin 和 end 形成对称

		//那为什么不这样写呢？
		//return *(--_it);
		//答：*(解引用)的目的只是要访问数据，怎么能把迭代器都修改了呢？如果这样写，你连续多用几次*，都不需要循环就已经把迭代器走完了
	}

	Ptr operator->()
	{
		//return _it->; //这里这样写的话编译不会报错，但实际上用的时候还是可能会出现问题的，因为这个表达式并不完整
		//return _it.operator->();
		
		//为了保证反向迭代器的正确性(就是要能达到我们想要的效果)
		return &(operator*()); //直接就这样写了
	}

	Self& operator++() 
	{
		--_it;
		return *this
	}

	Self& operator--()
	{
		++_it;
		return *this;
	}

	bool operator!=(const Self& s)
	{
		return _it != s._it;
	}
};

补充：迭代器从性质方面的分类
1、单向 ex：forward_list(单向链表的迭代器) 只支持++

注：单向迭代器没有对应的反向迭代器(因为它不支持--)
2、双向 ex：list(双向链表的迭代器) 支持++、--
3、随机 ex：vector/deque 支持++、--、+、-
补充：迭代器从功能方面的分类
1、正向
2、反向
3、const

3、list与vector的对比

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

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

本文到此就结束了，有何错误，请指点，感谢您的阅读。

c code

关注

12
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
C++中list容器的特性及使用介绍(超详细！！)

1.1 list的介绍list文档链接：kw=list注：C++库里自带的list是带头双向循环链表1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2.list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过两个指针分别指向其前一个元素和后一个元素。3. list与forward_list(单向链表)非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
复制链接

扫一扫