# Double Hashing

Double hashing is a collision resolving technique in Open Addressed Hash tables. Double hashing uses the idea of applying a second hash function to key when a collision occurs.

Advantages of Double hashing

• The advantage of Double hashing is that it is one of the best form of probing, producing a uniform distribution of records throughout a hash table.
• This technique does not yield any clusters.
• It is one of effective method for resolving collisions.

Double hashing can be done using :
(hash1(key) + i * hash2(key)) % TABLE_SIZE
Here hash1() and hash2() are hash functions and TABLE_SIZE
is size of hash table.
(We repeat by increasing i when collision occurs)

First hash function is typically hash1(key) = key % TABLE_SIZE
A popular second hash function is : hash2(key) = PRIME – (key % PRIME) where PRIME is a prime smaller than the TABLE_SIZE.
A good second Hash function is:

• It must never evaluate to zero
• Must make sure that all cells can be probed ## CPP

 `/*``** Handling of collision via open addressing``** Method for Probing: Double Hashing``*/` `#include ``#include ``#include ``using` `namespace` `std;``#define MAX_SIZE 10000001ll` `class` `doubleHash {` `    ``int` `TABLE_SIZE, keysPresent, PRIME;``    ``vector<``int``> hashTable;``    ``bitset isPrime;` `    ``/* Function to set sieve of Eratosthenes. */``    ``void` `__setSieve(){``        ``isPrime = isPrime = 1;``        ``for``(``long` `long` `i = 2; i*i <= MAX_SIZE; i++)``            ``if``(isPrime[i] == 0)``                ``for``(``long` `long` `j = i*i; j <= MAX_SIZE; j += i)``                    ``isPrime[j] = 1;` `    ``}` `    ``int` `inline` `hash1(``int` `value){``        ``return` `value%TABLE_SIZE;``    ``}``    ` `    ``int` `inline` `hash2(``int` `value){      ``        ``return` `PRIME - (value%PRIME);``    ``}` `    ``bool` `inline` `isFull(){``        ``return` `(TABLE_SIZE == keysPresent);``    ``}` `    ``public``:` `    ``doubleHash(``int` `n){``        ``__setSieve();``        ``TABLE_SIZE = n;` `        ``/* Find the largest prime number smaller than hash table's size. */``        ``PRIME = TABLE_SIZE - 1;``        ``while``(isPrime[PRIME] == 1)``            ``PRIME--;` `        ``keysPresent = 0;` `        ``/* Fill the hash table with -1 (empty entries). */``        ``for``(``int` `i = 0; i < TABLE_SIZE; i++)``            ``hashTable.push_back(-1);``    ``}` `    ``void` `__printPrime(``long` `long` `n){``        ``for``(``long` `long` `i = 0; i <= n; i++)``            ``if``(isPrime[i] == 0)``                ``cout<

Output

```Status of hash table after initial insertions : -1, 66, -1, -1, -1, -1, 123, -1, -1, 87, -1, 115, 12,

Search operation after insertion :
12 present
115 present
Status of hash table after deleting elements : -1, -2, -1, -1, -1, -1, -2, -1, -1, -2, -1, 115, 12, ```

Here is an Easy implementation of Double Hashing in Python.

Note: It’s written in python3.

## Python3

 `class` `DoubleHashing:``    ``def` `__init__(``self``, TableSize ``=` `1111111``):``        ``self``.ts ``=` `TableSize``        ``self``.``List` `=` `[``None``]``*``self``.ts``        ``self``.count ``=` `0` `#to count element in list``        ` `    ``def` `nearestPrime(``self``):``        ``for` `l ``in` `range``((``self``.ts``-``1``),``1``,``-``1``):``            ``flag ``=` `True``            ``for` `i ``in` `range``(``2``, ``int``(l``*``*``0.5``)``+``1``):``                ` `                ``if` `l``%``i ``=``=` `0``:``                    ``flag ``=` `False``                    ``break` `            ``if` `flag:``                ``return` `l` `        ``return` `3` `#default prime number`  `    ``def` `Hx1(``self``,key): ``#HashFunction 1 or Default Hash function when there is no collision.``        ``return` `key``%``self``.ts` `    ``def` `Hx2(``self``, key): ``#Hash Function 2 only used when collision occurs.``        ``return` `self``.nearestPrime() ``-` `(key``%` `self``.nearestPrime())         ``#Formula: PRIME - (KEY % PRIME), Here always PRIME < TABLE_SIZE``        `  `    ``def` `dHasing(``self``, key):``        ``if` `self``.count ``=``=` `self``.ts:``            ``print``(``"List is Full"``)``            ``return` `self``.``List` `        ``elif` `self``.``List``[``self``.Hx1(key)] ``=``=` `None``:``            ``self``.``List``[``self``.Hx1(key)] ``=` `key``            ``self``.count ``+``=``1``            ``print``(f``"Entered key: {key} at index {self.Hx1(key)}"``)``            ` `        ``else``:``            ``comp ``=` `False``            ``i ``=` `1``            ``while` `not` `comp:    ` `                ``index ``=` `(``self``.Hx1(key) ``+` `i``*``self``.Hx2(key))``%``self``.ts  ``# Index = ( HashFunc1 - i*HashFunc2)%TABle_SIZE` `                ``if` `self``.``List``[index] ``=``=` `None``:``                    ``self``.``List``[index] ``=` `key``                    ``print``(f``"Entered key: {key} at index {index}"``)``                    ``comp ``=` `True``                    ``self``.count ``+``=``1``                ``else``:``                    ``i ``+``=``1``        ``return` `self``.``List`   `    ``def` `PrintHashList(``self``):``        ``for` `i ``in` `range``(``0``, ``len``(``self``.``List``)):``            ``print``(``self``.``List``[i])` `    `  `def` `main():` `    ``tableSize ``=` `5` `#Taking 5 as size of the hash Table``    ``DHash ``=` `DoubleHashing(tableSize)` `    ``InputElements ``=` `[``4``,``11``, ``29``, ``1``, ``5``]` `    ``for` `i ``in` `InputElements:``        ``DHash.dHasing(i)`  `    ``print``(``'\n'``)``    ``print``(``"The Hash List After Entering Elements"``)``    ``DHash.PrintHashList() ``#Printing the resultant HashList.`    `if` `__name__ ``=``=``"__main__"``:``    ``main()`     `        `   `           `

Output

```Entered key: 4 at index 4
Entered key: 11 at index 1
Entered key: 29 at index 0
Entered key: 1 at index 3
Entered key: 5 at index 2

The Hash List After Entering Elements
29
11
5
1
4```

My Personal Notes arrow_drop_up