開放定址法（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 互素。

以下是開放定址法的一個類的定義的例子：

1. #ifndef _OPEN_ADDRESSING_HASH_H_
2. #define _OPEN_ADDRESSING_HASH_H_
3. /************************************************************************ 
4.  演算法導論 
5.  開放定址法散列表，本全程採用雙重雜湊的雜湊函式，其中 h1(k) = k % m， 
6.  h2(k) = 1 + k % (m - 1) 
7.  ************************************************************************/
8. #include <stdexcept>
9. template <class T>  
10. class OpenAddressingHash{  
11. public:  
12.     // 定義一個雜湊元素型別
13.     struct Node {  
14.         friendclass OpenAddressingHash < T > ;  
15.         // 雜湊元素鍵值，key 必須 >= 0，當 key == -1 時，表示槽是空的，
16.         // 當 key == -2 時表示槽內元素已刪除
17.         int key;  
18.         T value;  
19.     private:  
20.         Node() :key(-1){}  
21.         Node(int k, const T& v) :key(k), value(v){}  
22.     };  
23.     // 插入一個元素
24.     Node* insert(size_t key, const T& value);  
25.     // 查詢一個元素
26.     Node* search(size_t key);  
27.     // 刪除一個雜湊元素
28.     void remove(size_t key);  
29. private:  
30.     // 散列表大小
31.     staticconstsize_t _table_size = 11;  
32.     // 散列表
33.     Node _table[_table_size];  
34.     // 雜湊函式
35.     size_t hash(size_t k, size_t);  
36.     // 輔助雜湊函式 h1 h2
37.     inlinesize_t hash1(size_t k);  
38.     inlinesize_t hash2(size_t k);  
39. };  
40. template <class T>  
41. typename OpenAddressingHash<T>::Node* OpenAddressingHash<T>::insert(size_t key, const T& value){  
42.     size_t i = 0;  
43.     while (i != _table_size) {  
44.         auto hashCode = hash(key, i);  
45.         auto node = &_table[hashCode];  
46.         // 如果槽中關鍵字與要插入的關鍵字相同，則修改元素的值
47.         if (node->key == key || node->key == -2 || node->key == -1){  
48.             node->key = static_cast<int>(key);  
49.             node->value = value;  
50.             return node;  
51.         }  
52.         ++i;  
53.     }  
54.     throw std::overflow_error("hash table overflow");  
55. }  
56. template <class T>  
57. typename OpenAddressingHash<T>::Node* OpenAddressingHash<T>::search(size_t key){  
58.     size_t i = 0;  
59.     while (i != _table_size)  
60.     {  
61.         auto hashCode = hash(key, i++);  
62.         if (_table[hashCode].key == key)  
63.             return &_table[hashCode];  
64.     }  
65.     return nullptr;  
66. }  
67. template <class T>  
68. void OpenAddressingHash<T>::remove(size_t key){  
69.     auto node = search(key);  
70.     if (node)  
71.         // 將 key 設定為 -2，表示當前槽元素已刪除
72.         // 不要將 key 設定為 -1，如果這樣可導致之後具有相同雜湊值的元素不可訪問
73.         node->key = -2;  
74. }  
75. template <class T>  
76. size_t OpenAddressingHash<T>::hash(size_t key, size_t i){  
77.     return (hash1(key) + i * hash2(key)) % _table_size;  
78. }  
79. template <class T>  
80. size_t OpenAddressingHash<T>::hash1(size_t key){  
81.     return key % _table_size;  
82. }  
83. template <class T>  
84. size_t OpenAddressingHash<T>::hash2(size_t key){  
85.     return key % (_table_size - 1) + 1;  
86. }  
87. #endif