散列表的开放寻址法

开放寻址法（open addressing）中，所有元素都存放在槽中，在链表法散列表中，每个槽中保存的是相应链表的指针，为了维护一个链表，链表的每个结点必须有一个额外的域来保存它的前戏和后继结点。开放寻址法不在槽外保存元素，不使用指针，也不必须为了维护一个数据结构使用额外的域，所有可以不用存储指针而节省的空间，使得可以用同样的空间来提供更多的槽，也潜在地减少了冲突，提高了检索速度。

为了使用开放寻址法插入一个元素，需要连续地检查散列表，或称为探查（probe），直到找到一个空槽来放置待插入的关键字为止。

有三种常用技术来计算开放寻址法中的探查序列：线性探查、二将探查和双重探查。

1.线性探查：给定个一个普通的散列函数 h':U->{0, 1, ..., m-1}，称之为辅助散列函数，线性探查方法采用的散列函数为：

h(k, i) = (h'(k) + 1) mode n，i = 0, 1, ...，m-1

给定一个一个关键字k，首先探查 T[h'(k)]，即由辅助散列函数所给出的槽位，再探查槽 T[h'(k) + 1], 依次类推，直至槽 T[m - 1]，然后，又绕到 T[0], T[1]，...，直到最后探查到槽 T[h'(k) - 1]，在线性探查方法中，初始探查位置决定了整个序列，故只有 m 种不同的探查序列。

2.二次探查：采用如下列式的散列函数：h(k, i) = (h'(k) + c1i + c2i^2) mod m

其中 h' 是一个辅助散列波函数，c1 和 c2 为正的辅助常数，i = 0, 1, ... , m - 1。

象线性探查一样，二次探查的初始探查位置决定了整个序列。

3.双重散列：双重散列是用于开放寻址法的最好方法之一，因为它所产生的排列具有随机选择排列的这么多特性。双重散列采用以下形式的散列函数：h(k, i) = (h1(k) + ih2(k)) mod m

其中 h1 和 h2 均为辅助散列函数。初始探查位置为 T[h1(k)]，后续的探查位置是前一位置加上偏移量 h2(k) 模 m。为了能查找整个散列表，值 h2(k) 必须要与表的大小 m 互素。

以下是开放寻址法的一个类的定义的例子：

[cpp]  view plain copy

1. #ifndef _OPEN_ADDRESSING_HASH_H_  
2. #define _OPEN_ADDRESSING_HASH_H_  
3.   
4. /************************************************************************ 
5.  算法导论 
6.  
7.  开放寻址法散列表，本全程采用双重散列的散列函数，其中 h1(k) = k % m， 
8.  h2(k) = 1 + k % (m - 1) 
9.  ************************************************************************/  
10.   
11. #include <stdexcept>  
12.   
13. template <class T>  
14. class OpenAddressingHash{  
15. public:  
16.     // 定义一个散列元素类型  
17.     struct Node {  
18.         friend class OpenAddressingHash < T > ;  
19.         // 散列元素键值，key 必须 >= 0，当 key == -1 时，表示槽是空的，  
20.         // 当 key == -2 时表示槽内元素已删除  
21.         int key;  
22.         T value;  
23.     private:  
24.         Node() :key(-1){}  
25.         Node(int k, const T& v) :key(k), value(v){}  
26.     };  
27.   
28.     // 插入一个元素  
29.     Node* insert(size_t key, const T& value);  
30.   
31.     // 查找一个元素  
32.     Node* search(size_t key);  
33.   
34.     // 删除一个散列元素  
35.     void remove(size_t key);  
36.   
37. private:  
38.     // 散列表大小  
39.     static const size_t _table_size = 11;  
40.     // 散列表  
41.     Node _table[_table_size];  
42.   
43.     // 散列函数  
44.     size_t hash(size_t k, size_t);  
45.     // 辅助散列函数 h1 h2  
46.     inline size_t hash1(size_t k);  
47.     inline size_t hash2(size_t k);  
48. };  
49.   
50. template <class T>  
51. typename OpenAddressingHash<T>::Node* OpenAddressingHash<T>::insert(size_t key, const T& value){  
52.     size_t i = 0;  
53.     while (i != _table_size) {  
54.         auto hashCode = hash(key, i);  
55.         auto node = &_table[hashCode];  
56.         // 如果槽中关键字与要插入的关键字相同，则修改元素的值  
57.         if (node->key == key || node->key == -2 || node->key == -1){  
58.             node->key = static_cast<int>(key);  
59.             node->value = value;  
60.             return node;  
61.         }  
62.         ++i;  
63.     }  
64.     throw std::overflow_error("hash table overflow");  
65. }  
66.   
67.   
68. template <class T>  
69. typename OpenAddressingHash<T>::Node* OpenAddressingHash<T>::search(size_t key){  
70.     size_t i = 0;  
71.     while (i != _table_size)  
72.     {  
73.         auto hashCode = hash(key, i++);  
74.         if (_table[hashCode].key == key)  
75.             return &_table[hashCode];  
76.     }  
77.     return nullptr;  
78. }  
79.   
80. template <class T>  
81. void OpenAddressingHash<T>::remove(size_t key){  
82.     auto node = search(key);  
83.     if (node)  
84.         // 将 key 设置为 -2，表示当前槽元素已删除  
85.         // 不要将 key 设置为 -1，如果这样可导致之后具有相同散列值的元素不可访问  
86.         node->key = -2;  
87. }  
88.   
89. template <class T>  
90. size_t OpenAddressingHash<T>::hash(size_t key, size_t i){  
91.     return (hash1(key) + i * hash2(key)) % _table_size;  
92. }  
93.   
94. template <class T>  
95. size_t OpenAddressingHash<T>::hash1(size_t key){  
96.     return key % _table_size;  
97. }  
98.   
99. template <class T>  
100. size_t OpenAddressingHash<T>::hash2(size_t key){  
101.     return key % (_table_size - 1) + 1;  
102. }  
103.   
104. #endif