关于map、hash_map 和 unordered_map 的简单性能测试

最新推荐文章于 2024-10-18 16:32:48 发布

原创最新推荐文章于 2024-10-18 16:32:48 发布 · 2.6k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#string #warnings #insert #测试 #数据结构 #n2

本文通过实验对比了C++标准库中的三种容器（map、hash_map、unordered_map）在插入、查找和删除操作上的性能差异，特别是在不同类型的键值（整型和字符串）下的表现。结果显示，对于整型键值，map在查找操作上表现出色；而对于字符串键值，unordered_map在插入和查找操作上更为高效。此外，文章还分析了不同类型键值对容器性能的影响，并提供了一个关键结论：在选择容器时，应综合考虑键值类型、所需性能和内存需求。

测试环境：
DELL Latitude D610
CPU:Pentium-M 1.73 GHz
内存：2.00GB
OS:Windows 2003
开发环境: Visual Studio 2010
编译参数：/MD /Ox /Ot /W3 /D "_CRT_SECURE_NO_WARNINGS" /D "_CRT_NONSTDC_NO_WARNINGS" /link /MACHINE:X86 kernel32.lib

测试用代码：

#include <hash_map>
#include <unordered_map>
#include <map>
#include <string>
#include <iostream>
#include <ctime>
#include <windows.h>
using namespace std;

const int TEST = 100000;

class test_cls {
public:
	test_cls(){}
	test_cls(const string& s1, const string& s2, const string& s3, const string& s4, int n1, int n2):
			str1(s1), str2(s2), str3(s3), str4(s4), num1(n1), num2(n2){}
private:
	string str1;
	string str2;
	string str3;
	string str4;
	int num1;
	int num2;
};

template<typename T>
void test1(const string& test_str)
{
	T t;
	typedef typename T::value_type the_type;
	clock_t start = clock();
	for(int i = 0; i < TEST; ++i)
		t.insert(the_type(i, test_cls("s1", "s2", "s3", "s4", 1, 2)));
	cout << test_str << " insert:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.find(i);
	
	cout << test_str << " find:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.erase(i);
	
	cout << test_str << " erase:" << clock() - start << endl;
}

int main()
{
	test1<map<int, test_cls> >("map");
	::Sleep(1000);
	test1<hash_map<int, test_cls> >("hash_map");
	::Sleep(1000);
	test1<unordered_map<int, test_cls> >("unordered_map");

	return 0;
}

结果（为了减小误差，我对代码进行了10次测试）：

map<int, test_cls>

次数	插入	查询	删除
1	125	15	78
2	125	15	63
3	125	15	63
4	125	15	63
5	109	16	78
6	109	16	78
7	125	15	78
8	125	15	78
9	125	15	63
10	125	15	78

hash_map<int, test_cls>

次数	插入	查询	删除
1	125	31	47
2	125	31	47
3	125	15	63
4	125	31	47
5	125	31	47
6	125	15	63
7	125	31	47
8	109	31	47
9	125	31	47
10	110	31	47

unordered_map<int, test_cls>

次数	插入	查询	删除
1	125	31	47
2	140	16	62
3	125	15	63
4	140	16	62
5	125	31	47
6	125	15	63
7	125	31	47
8	109	31	47
9	125	31	47
10	125	31	47

从上面的结果来看，map、hash_map 和 unordered_map在插入上性能差不多，但在查询上map的性能更好，而在删除上hash_map 和 unordered_map性能差不多。相比各类书籍和网上对 hash_map 和 unordered_map 与 map 的性能描述来说，似乎大相径庭。

其实这在情理之中。因为，此处使用的key类型为int，对于数值型来说（包括;char、short、long）它们在map中排序(<) 和 hash_map 和 unordered_map中的散列值计算和比较(==)都是基于基本的内置运算，效率上没什么太大差异，因此，在插入上结果几乎相同，至于在查询上，之所以map较快，也是因为它只是对key在做简单<比较，而 hash_map 和 unordered_map 却要再次计算查询量的散列值而后再做==比较。至于删除，因为map内部是会对数据进行排序的，因此，相比hash_map 和 unordered_map不排序的而言，其在删除时除了要进行查询、移除、修正外还需要对数据结构进行调整

为了验证上述结论，我将key由int改为string：

#include <hash_map>
#include <unordered_map>
#include <map>
#include <string>
#include <iostream>
#include <ctime>
#include <cstdio>
#include <windows.h>
using namespace std;

const int TEST = 100000;

class test_cls {
public:
	test_cls(){}
	test_cls(const string& s1, const string& s2, const string& s3, const string& s4, int n1, int n2):
			str1(s1), str2(s2), str3(s3), str4(s4), num1(n1), num2(n2){}
private:
	string str1;
	string str2;
	string str3;
	string str4;
	int num1;
	int num2;
};

template<typename T>
void test1(const string& test_str)
{
	T t;
	typedef typename T::value_type the_type;
	clock_t start = clock();
	for(int i = 0; i < TEST; ++i)
		t.insert(the_type(i, test_cls("s1", "s2", "s3", "s4", 1, 2)));
	cout << test_str << " insert:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.find(i);
	
	cout << test_str << " find:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.erase(i);
	
	cout << test_str << " erase:" << clock() - start << endl;
}

template<typename T>
void test2(const string& test_str)
{
	T t;
	typedef typename T::value_type the_type;
	string* fill_str = new string[TEST];
	char tmp[10];
	for(int i = 0; i < TEST; ++i)
	{
		sprintf(tmp, "%d", i);
		fill_str[i] = tmp;
	}
	clock_t start = clock();
	for(int i = 0; i < TEST; ++i)
		t.insert(the_type(fill_str[i], test_cls("s1", "s2", "s3", "s4", 1, 2)));
	cout << test_str << " insert:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.find(fill_str[i]);
	
	cout << test_str << " find:" << clock() - start << endl;
	
	start = clock();
	for(int i = 0; i < TEST; ++i)
		t.erase(fill_str[i]);
	
	cout << test_str << " erase:" << clock() - start << endl;
}

int main()
{
	//test1<map<int, test_cls> >("map");
	//::Sleep(1000);
	//test1<hash_map<int, test_cls> >("hash_map");
	//::Sleep(1000);
	//test1<unordered_map<int, test_cls> >("unordered_map");
	
	test2<map<string, test_cls> >("map");
	::Sleep(1000);
	test2<hash_map<string, test_cls> >("hash_map");
	::Sleep(1000);
	test2<unordered_map<string, test_cls> >("unordered_map");

	return 0;
}

结果：

map<string, test_cls>