STL容器使用对比分析及各容器的遍历方式总结

一、STL容器对比分析

1.静态数组和动态数组vector可以随机访问，不需要逐个元素遍历，list不支持随机访问，查找元素比数组慢，但插入元素比数组方便，数组在中间插入时插入位置后面的所有元素都要移动。

2.deque综合了vector和list的优点，是分段连续的内存空间连在一起，他和list一样都有push_front,push_back,pop_front,pop_back,且和vector一样支持at和[],支持随机迭代器访问，但元素的地址也需要计算，但比list访问效率高很多;

3.queue和stack底层使用deque实现，封闭其一端即可，queue是一种队列结构(先进后出)，stack是一种栈结构(后进先出)，与deque一样它们不支持遍历，无迭代器，支持push和pop的操作；

4.map set底层都是红黑树，因而在内存中都是有序的，其中map按key的ascii码排序，且他们都自动抛弃重复元素。

5.multimap和maltiset允许重复。

6.unordered_map 和unordered_set底层是哈希表实现，查询效率提升，但哈希表建立时比较耗时；此外unordered_set遍历的顺序即为插入时的顺序，而unordered_map的顺序无规律，遍历结果见下午的代码。

二、容器遍历测试及程序执行结果

特此将所有容器的遍历方式及遍历的结果做个记录，便于日后查阅：

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <list>
#include <forward_list>
#include <queue>
#include <deque>
#include <array>
#include <stack>

using namespace std;

int main()
{
	vector<int>v1{0,1,2,3,4,5};
	cout << "*v1.begin():" << *v1.begin()<< "*(v1.end()-1):"<<*(v1.end()-1)<<endl;
	for (auto it = v1.begin(); it <v1.end(); it++)
	{
		cout << "vector:" << *it << endl;//与插入顺序一致
	}

	//底层用红黑树实现，自然有序，但占用空间大，每个节点要存父子节点，因为有序查找效率高，但速度还是比不了unordered_map
	map<string, string> m{ { "z", "11" }, { "a", "22" }, { "b", "dd" }, { "c", "00" }, { "aa", "11" }, {"c","01"}, {"d","00"} };//value可以重key不能重，所以{"c","01"}插入无效
	for (auto it = m.begin(); it != m.end(); it++)
		cout << "map :" << it->first << ":" << it->second << endl;//自动排序，按it->first的ascii码大小排序


	//底层用hash table实现，所以元素无须，查找很快，但哈希表的建立比较耗时
	unordered_map<string, string> um{ { "z", "11" }, { "a", "22" }, { "b", "dd" }, { "c", "00" }, { "aa", "11" }, { "c", "01" }, { "d", "00" } };//同map,value可以重key不能重，所以{"c","01"}插入无效
	for (auto it = um.begin(); it != um.end(); it++)
		cout << "unordered_map:" << it->first << ":" << it->second << endl;//打印结果排序无规则，和插入顺序无关

	multimap<string, string> mm{ { "z", "11" }, { "a", "22" }, { "b", "dd" }, { "c", "00" }, { "aa", "11" }, { "c", "01" }, { "d", "00" }, { "d", "00" } };
	for (auto it = mm.begin(); it != mm.end(); it++)
		cout << "multimap:" << it->first << ":" << it->second << endl;//自动排序，按it->first的ascii码大小排序，key和value皆可重复


	set<string> s{ "c", "b", "a", "d","a" };
	for (auto it = s.begin(); it != s.end(); it++)
		cout << "set:" << *it << endl;//自动排序，按ascii码大小排序,自动去重

	unordered_set<string> us{ "c", "b", "a", "d","a"};
	for (auto it = us.begin(); it != us.end(); it++)
		cout << "unordered_set:" << *it << endl;//和插入的顺序一致，自动去重，注意对比unordered_map

	multiset<string> ms{ "c", "b", "a", "d", "a" };
	for (auto it = ms.begin(); it != ms.end(); it++)
		cout << "multiset:" << *it << endl;//自动排序，按ascii码大小排序,可重複，打印结果 a a b c d

	list<string> lst{ "c", "b", "a", "d" };
	for (auto it = lst.begin(); it != lst.end(); it++)
		cout << "list:" << *it << endl;//和插入的顺序一致

	forward_list<string> flst{ "c", "b", "a", "d" };
	for (auto it = flst.begin(); it != flst.end(); it++)
		cout << "forward_list:" << *it << endl;//和插入的顺序一致

	//queue<string> qu{ "c","b","a","d" };//queue和dequeue没有迭代器,也没有和前面容易一样的初始化方式,访问元素的唯一方式是遍历容器内容，并移除访问过的每一个元素
	queue <string> qu;
	qu.push("c");
	qu.push("b");
	qu.push("a");
	qu.push("d");
	while (!qu.empty())
	{
		cout << "queue:" << qu.front() << endl; //先进先出
		qu.pop();
	}

	deque <string> dq;
	dq.push_back("c");//可以从两端push
	dq.push_back("b");
	dq.push_back("a");
	dq.push_back("d");
	while (!dq.empty())
	{
		cout << "deque:" << dq.front() << endl;
		dq.pop_front();
		//dq.pop_back();//可以从两端pop
	}

	stack <string> sk;
	sk.push("c");//可以从两端push
	sk.push("b");
	sk.push("a");
	sk.push("d");
	while (!sk.empty())
	{
		cout << "stack:" << sk.top() << endl;//倒序，因为先进后出
		sk.pop();
	}

	system("pause");
	return 0;
}

程序执行结果：

*v1.begin():0 *(v1.end()-1):5
vector:0
vector:1
vector:2
vector:3
vector:4
vector:5
map :a:22
map :aa:11
map :b:dd
map :c:00
map :d:00
map :z:11
unordered_map:b:dd
unordered_map:z:11
unordered_map:a:22
unordered_map:c:00
unordered_map:aa:11
unordered_map:d:00
multimap:a:22
multimap:aa:11
multimap:b:dd
multimap:c:00
multimap:c:01
multimap:d:00
multimap:d:00
multimap:z:11
set:a
set:b
set:c
set:d
unordered_set:c
unordered_set:b
unordered_set:a
unordered_set:d
multiset:a
multiset:a
multiset:b
multiset:c
multiset:d
list:c
list:b
list:a
list:d
forward_list:c
forward_list:b
forward_list:a
forward_list:d
queue:c
queue:b
queue:a
queue:d
deque:c
deque:b
deque:a
deque:d
stack:d
stack:a
stack:b
stack:c