小解List的使用【C++】

一. List

学习了STL，也已经到了List的内容
因为List与string以及vector比起来还是有很大不同的，所以这里稍微除了一篇小博客主要来讲解一下
相对于vector以及string，List中比较特殊的部分。

1.1. 与vector的不同

我们再学习这个List之前：
大部分人应该都已经知道list的底层实际上是：双向带头循环链表
这个其实以前博主再博客中实现过。

这里也不深究

string和vector实际上本质是顺序表

这两个类型的最大区别就是：
vector在内存中相当于动态开辟的数组，地址是连续的

链表中的节点则不是连续的，在内存中表现的是断开的，不连续的形式

所以vector的区别和使用上的区别也都是围绕着这个展开的。

与string有较大的不一样，因为空间不连续

1.2 与vector的使用不同

这里主要挑出来几个常用的功能
来体验一下vector与list的区别。

1.2.1 迭代器失效

还记得在vector中的迭代器失效吗

就是当使用迭代器进行insert和erase后，
重新使用迭代器对象进行操作
因为迭代器指向的位置虽然没变，但是指向的值却已经发生了变化。
在vs编译器下，直接限制了用户对erase与insert后的指针对象的使用。

#include<iostream>
#include<vector>
#include"vector.h"
int main()
{
	std::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	std::vector<int>::iterator begin = v1.begin();
	v1.erase(begin);
	while (begin != v1.end())
	{
		std::cout << *begin;
		begin++;
	}
}

就是上面的情况。

但是我们把目光转向list，看看list中是否存在迭代器失效的结果。

1.2.2. insert

这里我们直接进行测试把

int main()
{
	vector<int> v1;
	vector<int>::iterator it = v1.begin();
	v1.insert(it, 1);
	v1.insert(it, 2);
}

这里先用vector进行测试
很明显是行不通的，因为it被连续调用了两次。

这里就用list进行测试：

这里能发现并没有报错。

这里其实我们细想一下也能明白

list使用insert时候
list中的地址指向的值没有发生变化
因为他们本身就是不连续的，数据插入后，他们指针指向的位置依旧还是原来的值。

所以不会出现和vector一样的情况——移动后，前面的元素，会取代原来的值所以指针指向的值就发生了变化。

所以用insert不会发生迭代器失效的问题。

这里又要提出一个小问题：
因为vector的地址是连续的，在insert中可以直接用：

v1.insert(it+5,2);

表示在迭代器的+5的位置处进行插入。

这里vector能这么用，是因为vector的迭代器能支持加减，因为vector的地址是连续的

但是list的话因为地址不一样，所以是不是可能就不行了。

这里我们来试一下

这里就非常明显的报错了。

所以我们list想在迭代器后面进行插入就要自己让迭代器去++；

比如这里：
想要到迭代器后的第三个位置进行插入

std::list<int>::iterator it=s1.begin();
for(int i=0;i<3;i++)
{
	it++;
}

1.2.3 erase

其实erase这里不用实验。想想就能知道了

erase的作用是删除节点。
那节点都删除了，迭代器指向的指针位置肯定也消失了。
所以这里就不实验了，毫无疑问。

那问题应该是怎么解决：
其实这里和vector里的一样：
it=it.erase();

it会自带返回迭代器
返回的指向对象正是迭代器删除的对象的下一个指向对象。

1.2.4 sort

我们知道在算法中有一个qsort算法。

但是在list中，list自带了一个qsort接口，方便用户进行排序。

但是这里我们并不提倡用这个qsort

因为：
sort()：
算法中的sort效率远高于list的sort效率
数据量差的越多，效率差距越大

因为算法中的sort用的是快速排序

而因为list中的地址不是连续的，所以并不能用快速排序，只能用归并排序进行实现

这里我们能来进行测试以下：

这里把测试函数塞进来：

void test2()
{
	int N = 1000000;//测试的数字的多少
	std::vector<int>v1;
	//添加随机值给vector
	for (int i = 0; i < N; i++)
	{
		auto s = rand();
		v1.push_back(s);

	}

	//给list添加随机值
	std::list<int> l1;
	for (int i = 0; i < N; i++)
	{
		auto s = rand();
		l1.push_back(s);

	}
	
	//排序list并记录时间
	int begin1 = clock();
	l1.sort();
	int end1 = clock();
	
	//排序vector并记录时间
	int begin2 = clock();
	sort(v1.begin(), v1.end());
	int end2 = clock();

	std::cout << "vector " << end2 - begin2 << std::endl;
	std::cout << "list " << end1 - begin1 << std::endl;
}

这里我们能看到list和vector的效率差距还是十分大的。

所以还是不推荐用list的sort的

那我们想要排序list中的数怎么办。

我们可以将list中的数字拷贝进vector中，然后再vector排序完了后，赋值给list

void test3()
{
	int N = 1000000;
	std::vector<int>v1;
	for (int i = 0; i < N; i++)
	{
		auto s = rand();
		v1.push_back(s);

	}


	std::list<int> l1;

	for (int i = 0; i < N; i++)
	{
		auto s = rand();
		l1.push_back(s);

	}


	int begin1 = clock();
	sort(v1.begin(), v1.end());
	int end1 = clock();



	int begin2 = clock();
	std::vector<int>v2;
	for (auto i : l1)
	{
		v2.push_back(i);
	}
	sort(v2.begin(), v2.end());
	size_t i = 0;
	//将vector赋值给list
	for (auto& z : l1)
	{
		z = v2[i++];
	}
	int end2 = clock();


	std::list<int> l2;
	for (int i = 0; i < N; i++)
	{
		auto s = rand();
		l2.push_back(s);
	}


	int begin3 = clock();
	l2.sort();
	int end3 = clock();



	std::cout << "vector " << end1 - begin1 << std::endl;
	std::cout << "list_good " << end2 - begin2 << std::endl;
	std::cout << "list " << end3 - begin3 << std::endl;

}

1.3. 其他接口

这里的其他接口就不进行演示了
这里贴个网址自己去使用即可：
List的其他接口

补充迭代器

这里因为vector与list有许多的不同。

所以他们的迭代器有很大的不同，这里就补充一下迭代器。

容器与迭代器的关系

我们都知道：

容器使用来存储数据的

算法是用来处理数据的。

而迭代器是用来链接容器和算法之间的桥梁。

有了迭代器，算法就可以通过访问迭代器改变容器中的数据。

所以对于迭代器来说要通过容器的性质来进行设计。
容器的不同会导致迭代器的类型也不同

迭代器的类型

这里的容器种类不同，迭代器的种类也不同。

迭代器的种类不同，我们能看到他们支持的运算符种类也不同。