探索hash_set

原文链接：http://blog.csdn.net/morewindows/article/details/7330323

Title:        STL系列之九 探索hash_set

Author:     MoreWindows

Blog:       http://blog.csdn.net/MoreWindows

E-mail:     [e-mail]

KeyWord:   C++ STL set hash_set 哈希表 链地址法

 

本文将着重探索hash_set比set快速高效的原因，阅读本文前，推荐先阅读本文的姊妹篇《STL系列之六 set与hash_set》

一．hash_set之基石——哈希表

    hash_set的底层数据结构是哈希表，因此要深入了解hash_set，必须先分析哈希表。哈希表是根据关键码值(Key-Value)而直接进行访问的数据结构，它用哈希函数处理数据得到关键码值，关键码值对应表中一个特定位置再由应该位置来访问记录，这样可以在时间复杂性度为O(1)内访问到数据。但是很有可能出现多个数据经哈希函数处理后得到同一个关键码——这就产生了冲突，解决冲突的方法也有很多，各大数据结构教材及考研辅导书上都会介绍大把方法。这里采用最方便最有效的一种——链地址法，当有冲突发生时将具同一关键码的数据组成一个链表。下图展示了链地址法的使用：

二．简化版的hash_table

    按照上面的分析和图示，并参考《编程珠玑》第15章中哈希表的实现，不难写出一个简单的哈希表，我们称之为简化版hash_table。该哈希表由一个指针数组组成，数组中每个元素都是链表的表头指针，程序分为hash_table.h，hash_table.cpp和main.cpp。

1.hash_table.h

[cpp] view plain copy

1. #pragma once  
2. #define NULL 0  
3. //简化版hash_table   
4. //by MoreWindows( http://blog.csdn.net/MoreWindows )  
5. struct Node  
6. {  
7.     int val;  
8.     Node *next;  
9.     Node(int n)  
10.     {  
11.         this->val = n;  
12.         this->next = NULL;  
13.     }  
14. };  
15. class hash_table  
16. {  
17. public:  
18.     hash_table(const int ntablesize);  
19.     ~hash_table();  
20.     bool insert(int n);  
21.     void insert(int *pFirst, int *pLast);  
22.     bool find(int n);  
23.     int  size();  
24.     int HashFun(int n);  
25. public:  
26.     int      m_nTableSize;  
27.     int      m_nTableDataCount;  
28.     Node**   m_ppTable;  
29. };  

2.hash_table.cpp

[cpp] view plain copy

1. //简化版hash_table  
2. //by MoreWindows( http://blog.csdn.net/MoreWindows )  
3. #include "hash_table.h"  
4. #include <malloc.h>  
5. #include <memory.h>  
6. hash_table::hash_table(const int ntablesize)  
7. {  
8.     m_nTableSize = ntablesize;  
9.     m_ppTable = (Node**)malloc(sizeof(Node*) * m_nTableSize);  
10.     if (m_ppTable == NULL)  
11.         return ;  
12.     m_nTableDataCount = 0;  
13.     memset(m_ppTable, 0, sizeof(Node*) * m_nTableSize);  
14. }  
15. hash_table::~hash_table()  
16. {  
17.     free(m_ppTable);  
18.     m_ppTable = NULL;  
19.     m_nTableDataCount = 0;  
20.     m_nTableSize = 0;  
21. }  
22. int inline hash_table::HashFun(int n)   
23. {  
24.     return (n ^ 0xdeadbeef) % m_nTableSize;  
25. }  
26. int hash_table::size()  
27. {  
28.     return m_nTableDataCount;  
29. }  
30. bool hash_table::insert(int n)  
31. {  
32.     int key = HashFun(n);  
33.     //在该链表中查找该数是否已经存在  
34.     for (Node *p = m_ppTable[key]; p != NULL; p = p->next)  
35.         if (p->val == n)  
36.             return true;  
37.     //在链表的头部插入  
38.     Node *pNode = new Node(n);  
39.     if (pNode == NULL)  
40.         return false;  
41.     pNode->next = m_ppTable[key];  
42.     m_ppTable[key] = pNode;  
43.     m_nTableDataCount++;  
44.     return true;  
45. }  
46. bool hash_table::find(int n)  
47. {  
48.     int key = HashFun(n);  
49.     for (Node *pNode = m_ppTable[key]; pNode != NULL; pNode = pNode->next)  
50.         if (pNode->val == n)  
51.             return true;  
52.     return false;  
53. }  
54. void hash_table::insert(int *pFirst, int *pLast)  
55. {  
56.     for (int *p = pFirst; p != pLast; p++)  
57.         this->insert(*p);  
58. }  

3．main.cpp

 在main.cpp中，对set、hash_set、简化版hash_table作一个性能测试，测试环境为Win7+VS2008的Release设置（下同）。

[cpp] view plain copy

1. //测试set，hash_set及简化版hash_table  
2. // by MoreWindows( http://blog.csdn.net/MoreWindows )  
3. #include <set>  
4. #include <hash_set>  
5. #include "hash_table.h"  
6. #include <iostream>  
7. #include <ctime>  
8. #include <cstdio>  
9. #include <cstdlib>  
10. using namespace std;  
11. using namespace stdext;  //hash_set  
12. void PrintfContainerElapseTime(char *pszContainerName, char *pszOperator, long lElapsetime)  
13. {  
14.     printf("%s 的 %s操作 用时 %d毫秒\n", pszContainerName, pszOperator, lElapsetime);  
15. }  
16. // MAXN个数据 MAXQUERY次查询  
17. const int MAXN = 5000000, MAXQUERY = 5000000;  
18. int a[MAXN], query[MAXQUERY];  
19. int main()  
20. {  
21.     printf("set VS hash_set VS hash_table(简化版) 性能测试\n");  
22.     printf("数据容量 %d个 查询次数 %d次\n", MAXN, MAXQUERY);  
23.     const int MAXNUM = MAXN * 4;  
24.     const int MAXQUERYNUM = MAXN * 4;  
25.     printf("容器中数据范围 [0, %d) 查询数据范围[0, %d)\n", MAXNUM, MAXQUERYNUM);  
26.     printf("--by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
27.       
28.     //随机生成在[0, MAXNUM)范围内的MAXN个数  
29.     int i;  
30.     srand((unsigned int)time(NULL));  
31.     for (i = 0; i < MAXN; ++i)  
32.         a[i] = (rand() * rand()) % MAXNUM;  
33.     //随机生成在[0, MAXQUERYNUM)范围内的MAXQUERY个数  
34.     srand((unsigned int)time(NULL));  
35.     for (i = 0; i < MAXQUERY; ++i)  
36.         query[i] = (rand() * rand()) % MAXQUERYNUM;  
37.   
38.     set<int>       nset;  
39.     hash_set<int>  nhashset;  
40.     hash_table   nhashtable(MAXN + 123);  
41.     clock_t  clockBegin, clockEnd;  
42.   
43.     //insert  
44.     printf("-----插入数据-----------\n");  
45.     clockBegin = clock();      
46.     nset.insert(a, a + MAXN);   
47.     clockEnd = clock();  
48.     printf("set中有数据%d个\n", nset.size());  
49.     PrintfContainerElapseTime("set", "insert", clockEnd - clockBegin);  
50.   
51.     clockBegin = clock();    
52.     nhashset.insert(a, a + MAXN);   
53.     clockEnd = clock();  
54.     printf("hash_set中有数据%d个\n", nhashset.size());  
55.     PrintfContainerElapseTime("hash_set", "insert", clockEnd - clockBegin);  
56.   
57.     clockBegin = clock();  
58.     for (i = 0; i < MAXN; i++)  
59.         nhashtable.insert(a[i]);   
60.     clockEnd = clock();  
61.     printf("hash_table中有数据%d个\n", nhashtable.size());  
62.     PrintfContainerElapseTime("Hash_table", "insert", clockEnd - clockBegin);  
63.   
64.     //find  
65.     printf("-----查询数据-----------\n");  
66.     int nFindSucceedCount, nFindFailedCount;   
67.     nFindSucceedCount = nFindFailedCount = 0;  
68.     clockBegin = clock();   
69.     for (i = 0; i < MAXQUERY; ++i)  
70.         if (nset.find(query[i]) != nset.end())  
71.             ++nFindSucceedCount;  
72.         else  
73.             ++nFindFailedCount;  
74.     clockEnd = clock();  
75.     PrintfContainerElapseTime("set", "find", clockEnd - clockBegin);  
76.     printf("查询成功次数： %d    查询失败次数： %d\n", nFindSucceedCount, nFindFailedCount);  
77.       
78.     nFindSucceedCount = nFindFailedCount = 0;  
79.     clockBegin = clock();    
80.     for (i = 0; i < MAXQUERY; ++i)  
81.         if (nhashset.find(query[i]) != nhashset.end())  
82.             ++nFindSucceedCount;  
83.         else  
84.             ++nFindFailedCount;  
85.     clockEnd = clock();  
86.     PrintfContainerElapseTime("hash_set", "find", clockEnd - clockBegin);  
87.     printf("查询成功次数： %d    查询失败次数： %d\n", nFindSucceedCount, nFindFailedCount);  
88.   
89.     nFindSucceedCount = nFindFailedCount = 0;  
90.     clockBegin = clock();    
91.     for (i = 0; i < MAXQUERY; ++i)  
92.         if (nhashtable.find(query[i]))  
93.             ++nFindSucceedCount;  
94.         else  
95.             ++nFindFailedCount;  
96.     clockEnd = clock();  
97.     PrintfContainerElapseTime("hash_table", "find", clockEnd - clockBegin);  
98.     printf("查询成功次数： %d    查询失败次数： %d\n", nFindSucceedCount, nFindFailedCount);  
99.     return 0;  
100. }  

在数据量为500万时测试结果如下：

从程序运行结果可以发现，我们自己实现的hash_table（简化版）在插入和查找的效率要远高于set。为了进一步分析，最好能统计hash_table中的各个链表的长度情况，这样可以有效的了解平均每次查找要访问多少个数据。写出统计hash_table各链表长度的函数如下：

[cpp] view plain copy

1. // by MoreWindows( http://blog.csdn.net/MoreWindows )  
2. void StatisticHashTable(hash_table &ht)  
3. {  
4.     const int MAXLISTLINE = 100;  
5.     int i, a[MAXLISTLINE], nExtendListNum;  
6.     nExtendListNum = 0;  
7.     memset(a, 0, sizeof(a[0]) * MAXLISTLINE);  
8.     for (i = 0; i < ht.m_nTableSize; i++)  
9.     {  
10.         int sum = 0;  
11.         for (Node *p = ht.m_ppTable[i]; p != NULL; p = p->next)  
12.             ++sum;  
13.         if (sum >= MAXLISTLINE)  
14.             nExtendListNum++;  
15.         else  
16.             a[sum]++;  
17.     }  
18.     printf("hash_table中链表长度统计：\n");  
19.     for (i = 0; i < MAXLISTLINE; i++)  
20.         if (a[i] > 0)  
21.         {  
22.             printf("   长度为%d的链表有%d个 这些链表中数据占总数据的%.2lf%%\n", i, a[i], (a[i] * i * 100.0) / ht.size());  
23.         }  
24.         printf("   长度超过%d的链表有%d个\n", MAXLISTLINE, nExtendListNum);  
25. }  

用此段代码得到链表长度的统计结果：

可以发现在hash_table中最长的链表也只有5个元素，长度为1和长度为2的链表中的数据占全部数据的89%以上。因此绝大数查询将仅仅访问哈希表1次到2次。这样的查询效率当然会比set（内部使用红黑树——类似于二叉平衡树）高的多。有了这个图示，无疑已经可以证明hash_set会比set快速高效了。但hash_set还可以动态的增加表的大小，因此我们再实现一个表大小可增加的hash_table。

三．强化版hash_table

    首先来看看VS2008中hash_set是如何实现动态的增加表的大小，hash_set是在hash_set.h中声明的，在hash_set.h中可以发现hash_set是继承_Hash类的，hash_set本身并没有太多的代码，只是对_Hash作了进一步的封装，这种做法在STL中非常常见，如stack栈和queue单向队列都是以deque双向队列作底层数据结构再加一层封装。

_Hash类的定义和实现都在xhash.h类中，微软对_Hash类的第一句注释如下——

        hash table -- list with vector of iterators for quick access。

哈哈，这句话说的非常明白。这说明_Hash实际上就是由vector和list组成哈希表。再阅读下代码可以发现_Hash类增加空间由_Grow()函数完成，当空间不足时就倍增，并且表中原有数据都要重新计算hash值以确定新的位置。

知道了_Hash类是如何运作的，下面就来考虑如何实现强化版的hash_table。当然有二个地方还可以改进：

1．_Hash类使用的list为双向链表，但在在哈希表中使用普通的单链表就可以了。因此使用STL中的vector再加入《STL系列之八 slist单链表》一文中的slist来实现强化版的hash_table。

2．在空间分配上使用了一个近似于倍增的素数表，最开始取第一个素数，当空间不足时就使用下一个素数。经过实际测试这种效果要比倍增法高效一些。

在这二个改进之上的强化版的hash_table代码如下：

[cpp] view plain copy

1. //使用vector< slist<T> >为容器的hash_table  
2. // by MoreWindows( http://blog.csdn.net/MoreWindows )  
3. template< class T, class container = vector<slist<T>> >  
4. class hash_table  
5. {  
6. public:  
7.     hash_table();  
8.     hash_table(const int ntablesize);  
9.     ~hash_table();  
10.     void clear();  
11.     bool insert(T &n);  
12.     void insert(T *pFirst, T *pLast);  
13.     bool erase(T &n);  
14.     void resize(int nNewTableSize);  
15.     bool find(T &n);  
16.     int size();  
17.     int HashFun(T &n);  
18. private:  
19.     static int findNextPrime(int curPrime);  
20. public:  
21.     int         m_nDataCount;  
22.     int         m_nTableSize;  
23.     container   m_Table;  
24.     static const unsigned int m_primes[50];  
25. };  
26. //素数表  
27. template< class T, class container>  
28. const unsigned int hash_table<T, container>::m_primes[50] = {  
29.     53, 97, 193, 389, 769, 1453, 3079, 6151, 1289, 24593, 49157, 98317,   
30.     196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917,   
31.     25165843, 50331653, 100663319, 201326611, -1  
32. };  
33. template< class T, class container>  
34. int inline hash_table<T, container>::HashFun(T &n)  
35. {  
36.     return (n ^ 0xdeadbeef) % m_nTableSize;  
37. }  
38. template< class T, class container>  
39. hash_table<T, container>::hash_table()  
40. {  
41.     m_nDataCount = 0;  
42.     m_nTableSize = m_primes[0];  
43.     m_Table.resize(m_nTableSize);  
44. }  
45. template< class T, class container>  
46. hash_table<T, container>::hash_table(const int ntablesize)  
47. {  
48.     m_nDataCount = 0;  
49.     m_nTableSize = ntablesize;  
50.     m_Table.resize(m_nTableSize);  
51. }  
52. template< class T, class container>  
53. hash_table<T, container>::~hash_table()  
54. {  
55.     clear();  
56. }  
57. template< class T, class container>  
58. void hash_table<T, container>::clear()  
59. {  
60.     for (int i = 0; i < m_nTableSize; i++)  
61.         m_Table[i].clear();  
62.     m_nDataCount = 0;  
63. }  
64. template< class T, class container>  
65. bool hash_table<T, container>::insert(T &n)  
66. {  
67.     int key = HashFun(n);  
68.     if (!m_Table[key].find(n))  
69.     {  
70.         m_nDataCount++;  
71.         m_Table[key].push_front(n);  
72.         if (m_nDataCount >= m_nTableSize)  
73.             resize(findNextPrime(m_nTableSize));  
74.     }  
75.     return true;  
76. }  
77. template< class T, class container>  
78. bool hash_table<T, container>::erase(T &n)  
79. {  
80.     int key = HashFun(n);  
81.     if (m_Table[key].remove(n))  
82.     {  
83.         m_nDataCount--;  
84.         return true;  
85.     }  
86.     else  
87.     {  
88.         return false;  
89.     }  
90. }  
91. template< class T, class container>  
92. void hash_table<T, container>::insert(T *pFirst, T *pLast)  
93. {  
94.     for (T *p = pFirst; p != pLast; p++)  
95.         this->insert(*p);  
96. }  
97. template< class T, class container>  
98. void hash_table<T, container>::resize(int nNewTableSize)  
99. {  
100.     if (nNewTableSize <= m_nTableSize)  
101.         return;  
102.     int nOldTableSize = m_nTableSize;  
103.     m_nTableSize = nNewTableSize;  
104.     container tempTable(m_nTableSize); //创建一个更大的表  
105.     for (int i = 0; i < nOldTableSize; i++)//将原表中数据重新插入到新表中  
106.     {  
107.         Node<T> *cur = m_Table[i].m_head;  
108.         while (cur != NULL)  
109.         {  
110.             int key = HashFun(cur->val);  
111.             Node<T> *pNext = cur->next;  
112.             cur->next = tempTable[key].m_head;  
113.             tempTable[key].m_head = cur;  
114.             cur = pNext;  
115.         }  
116.         m_Table[i].m_head = NULL;  
117.     }  
118.     m_Table.swap(tempTable);  
119. }  
120. template< class T, class container>  
121. int hash_table<T, container>::size()  
122. {  
123.     return m_nDataCount;  
124. }  
125. template< class T, class container>  
126. bool hash_table<T, container>::find(T &n)  
127. {  
128.     int key = HashFun(n);  
129.     return m_Table[key].find(n);  
130. }  
131. //在素数表中找到比当前数大的最小数  
132. template< class T, class container>  
133. int hash_table<T, container>::findNextPrime(int curPrime)  
134. {  
135.     unsigned int *pStart = (unsigned int *)m_primes;  
136.     while (*pStart <= curPrime)  
137.         ++pStart;  
138.     return *pStart;  
139. }  

下面再对set、hash_set、强化版hash_table的性能测试：

测试结果一（数据量500万）：

测试结果二（数据量1千万）：

测试结果三（数据量1千万）：

可以看出，由于强化版hash_table的哈希表在增加表空间大小时会花费额外的一些时间，所以插入数据的用时与STL提供的hash_set用时相差不多了。但查找还是比hash_set要快的一些。

四．结语

从简化版到强化版的hash_table，我们不仅知道了hash_set底层数据结构——哈希表的运作机制，还知道了如何实现大小动态变化的哈希表。达到了本文让读者了解hash_set快速高效的原因。当然本文所给hash_table距真正的hash_set还有不小的距离，有兴趣的读者可以进一步改进。

此外，本文所示范的哈希表也与最近流行的NoSql数据库颇有渊源， NoSql数据库也是通过Key-Value方式来访问数据的（访问数据的方式上非常类似哈希表），其查找效率与传统的数据库相比也正如本文中hast_set与set的比较。正因为NoSql数据库在基础数据结构上的天然优势，所以它完全可以支持海量数据的查询修改且对操作性能要求很高场合如微博等。

 

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7330323