德鲁周记01 -- STL 中map和unordered_map区别，vector添加元素push_back()和emplace_back()区别

map和unordered_map区别

这周在刷leetcode的时候发现高赞题解的代码和我几乎一模一样，但性能却比我好很多，唯一的区别就是他用了一个unordered_map，而我用的是map，于是我专门去研究了一下这两个容器的差别。

内部实现机理不同：

map： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，而AVL是严格平衡二叉搜索树），红黑树具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素。因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行的操作。map中的元素是按照二叉搜索树（又名二叉查找树、二叉排序树，特点就是左子树上所有节点的键值都小于根节点的键值，右子树所有节点的键值都大于根节点的键值）存储的，使用中序遍历可将键值按照从小到大遍历出来。
unordered_map: unordered_map内部实现了一个哈希表（也叫散列表，通过把关键码值映射到Hash表中一个位置来访问记录，查找的时间复杂度可达到O(1)，其在海量数据处理中有着广泛应用）。因此，其元素的排列顺序是无序的。

优缺点以及适用处：
map：

优点：
有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作红黑树，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高
缺点： 空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点、孩子节点和红/黑性质，使得每一个节点都占用大量的空间
适用处：对于那些有顺序要求的问题，用map会更高效一些

unordered_map：

优点： 因为内部实现了哈希表，因此其查找速度非常的快
缺点： 哈希表的建立比较耗费时间
适用处：对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map
总结：

内存占有率的问题就转化成红黑树 VS hash表 , 还是unorder_map占用的内存要高。
但是unordered_map执行效率要比map高很多
对于unordered_map或unordered_set容器，其遍历顺序与创建该容器时输入的顺序不一定相同，因为遍历是按照哈希表从前往后依次遍历的

二者的效率对比：

二者既然有十分相似的功能，不免会在选择时产生迷茫，到底哪一个数据结构能够满足要求，并且执行的速度又足够快。

实验设计：

无序情况下的随机存储查询对比

for (int xx = 1000; xx != 11000; xx += 1000)
	{
		vector<int> t;
		vector<int> ti;
		int b = 0;
		map<int, int> a;
		for (int n = 0; n != 10000; n++)
		{
			srand(time(nullptr));
			vector<int> key;
			vector<int> val;
			for (int i = 0; i != xx; i++)
			{
				key.emplace_back(rand());
				val.emplace_back(rand());
			}
			LARGE_INTEGER insertstart;
			QueryPerformanceCounter(&insertstart);
			for (int i = 0; i != xx; i++)
			{
				a[key[i]] = val[i];
			}
			LARGE_INTEGER insertend;
			QueryPerformanceCounter(&insertend);
			ti.emplace_back(insertend.QuadPart - insertstart.QuadPart);
			vector<int> find;
			for (int i = 0; i != 10000; i++)
			{
				find.emplace_back(key[rand() % key.size()]);
			}
 
			LARGE_INTEGER start;
			QueryPerformanceCounter(&start);
			for (auto i :find)
			{
				b += a[i];
			}
			LARGE_INTEGER end;
			QueryPerformanceCounter(&end);
			t.emplace_back(end.QuadPart - start.QuadPart);
			a.clear();
		}
		cout << b << endl;
		LARGE_INTEGER f;
		QueryPerformanceFrequency(&f);
		double avg = static_cast<double>(accumulate(t.begin(), t.end(), 0)) / t.size();
		double avginsert = static_cast<double>(accumulate(ti.begin(), ti.end(), 0)) / ti.size();
		int longestdur = *max_element(t.begin(), t.end());
		int shortestdur = *min_element(t.begin(), t.end());
		cout << "rbt" << xx << endl;
		cout << "avg:" << avg / f.QuadPart * 1000 << " max-min:" << static_cast<double> (longestdur - shortestdur) / avg << endl;
		longestdur = *max_element(ti.begin(), ti.end());
		shortestdur = *min_element(ti.begin(), ti.end());
		cout << "insert time:" << avginsert / f.QuadPart * 1000 <<" max:" << static_cast<double> (longestdur) / f.QuadPart*1000<<" min:"<< static_cast<double> (shortestdur) / f.QuadPart * 1000 << endl;
		double var = 0.0;
		for (auto i : t)
		{
			var += (i - avg)*(i - avg);
		}
		var = var / (t.size() - 1);
		cout << "var:" << var / f.QuadPart * 1000 << endl;
	}

该程序为VC的程序，使用QueryPerformanceCounter来获取执行时间，本次实验使用10000次存n个随机value，取10000个随机key的平均时间作为实验数据，n从1000至10000每1000取一点，从10000至100000每10000取一点。可将map修改为unordered_map来获得unordered_map的结果。

结论

绿线为map的随机访问时间，红线为unordered_map的随机访问时间，可以看出，使用hash表的unordered_map在随机访问上的优势极其明显。与理论值类似，红黑树的随机访问平均时间呈对数状。

同样的，在插入时间上也有类似的结论，二者的插入时间都呈对数增长，map的时间明显高于 unordered_map。

因此如果在不涉及顺序并且能够设计出较好的hash算法（碰撞较少）的情况下，unordered_map是最好的选择。但是如果考虑顺序的因素，仍旧需要选择map，链表数组等线性结构在排序方面是优于二叉树的，但是当涉及到动态插入的情况时，这些线性结构显得力不从心，以下是在红黑树和链表在排序和动态插入时对比的结果使用的数据为100000个

rbt init time:0.0614347
list init time:0.0227488
rbt insert time:0.0629764
list insert time:60.7506

可以看出，链表排序速度较快，但是有序插入时速度远远低于红黑树，因此在考虑有序的动态数据结构时，红黑树仍旧是较好的选择。

vector添加元素push_back()和emplace_back()区别

下面也是在刷题中高赞题解学到的知识，就是两种插入方式的不同

emplace_back() 和 push_back() 的区别

emplace_back() 和 push_back() 的区别，就在于底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。

为了让大家清楚的了解它们之间的区别，我们创建一个包含类对象的 vector 容器，如下所示：

#include <vector> 
#include <iostream> 
using namespace std;
class testDemo
{
public:
    testDemo(int num):num(num){
        std::cout << "调用构造函数" << endl;
    }
    testDemo(const testDemo& other) :num(other.num) {
        std::cout << "调用拷贝构造函数" << endl;
    }
    testDemo(testDemo&& other) :num(other.num) {
        std::cout << "调用移动构造函数" << endl;
    }
private:
    int num;
};
int main()
{
    cout << "emplace_back:" << endl;
    std::vector<testDemo> demo1;
    demo1.emplace_back(2);  
    cout << "push_back:" << endl;
    std::vector<testDemo> demo2;
    demo2.push_back(2);
}

运行结果为：
emplace_back:
调用构造函数
push_back:
调用构造函数
调用移动构造函数

在此基础上，读者可尝试将 testDemo 类中的移动构造函数注释掉，再运行程序会发现，运行结果变为：

emplace_back:
调用构造函数
push_back:
调用构造函数
调用拷贝构造函数

由此可以看出，push_back() 在底层实现时，会优先选择调用移动构造函数，如果没有才会调用拷贝构造函数。

显然完成同样的操作，push_back() 的底层实现过程比 emplace_back() 更繁琐，换句话说，emplace_back() 的执行效率比 push_back() 高。因此，在实际使用时，建议大家优先选用 emplace_back()。

PS.由于 emplace_back() 是 C++ 11 标准新增加的，如果程序要兼顾之前的版本，还是应该使用 push_back()。