## Table of contents

Hash tables are one of the most commonly used data structures in computer programming. They are used to store key-value pairs and are often used to implement lookup tables, such as dictionaries.

Hash tables are typically implemented using an array. The array is divided into a number of slots, and each slot contains a key-value pair. The key is used to index the array, and the value is the data that is stored at that index.

Hash tables are usually implemented with a hashing function, which is used to map keys to values. The hashing function is used to calculate the index of the array where the key-value pair will be stored.

It is a common believe that if you cannot come up with a good hashing function, you simply do not understand hash tables. So, how do you come up with a hashing function that will be consistent and efficient in producing the same results?

## Hashing function

The main idea behind hashing is to distribute the entries (key/value pairs) across an array of buckets. Each bucket can then be searched individually, which is much more efficient than searching the entire array.

A good hash function should have the following properties:

It should be easy to compute.

It should be uniformly distributed.

It should be deterministic.

## Modulus Operator

The modulus operator is a commonly used operator in hash functions. The modulus operator calculates the remainder of a division operation. For example, the expression 5 % 3 would evaluate to 2. The modulus operator is often used in hash functions because it can distribute the keys more evenly.

A common way to create a hash function is to use a modulus operator. For example, if we have an array of size 10, we can use the modulus operator to compute an index as follows:

`index = key % 10`

This would give us an index in the range 0-9, which is perfect for our 10 bucket array.

There are many techniques that can be used to improve the performance of modulus operator.

#### Technique 1: Use a Prime Number Modulus

One technique that can be used to improve the performance of hash tables is to use a prime number modulus. A prime number is a number that is only divisible by 1 and itself. For example, the number 7 is a prime number.

The use of a prime number modulus can help to improve the performance of hash tables because it can help to avoid certain types of collisions. A collision is when two keys are mapped to the same index. When using a prime number modulus, the chances of collisions are reduced because the number of possible indexes is reduced.

#### Technique 2: Use a Power of Two Modulus

Another technique that can be used to improve the performance of modulus operator is to use a power of two modulus. A power of two modulus is when the modulus is a power of two. For example, the modulus could be 2, 4, 8, 16, 32, 64, 128, 256, or 512.

The use of a power of two modulus can help to improve the performance of hash tables because it can help to avoid certain types of collisions. When using a power of two modulus, the chances of collisions are reduced because the number of possible indexes is reduced.

#### Technique 3: Use a Multiplicative Congruential Generator

Another technique that can be used to improve the performance of hash tables is to use a multiplicative congruential generator. A multiplicative congruential generator is a mathematical function that is used to generate a sequence of numbers. The use of a multiplicative congruential generator can help to improve the performance of hash tables because it can help to avoid certain types of collisions.

The multiplicative congruential generator that is used in this technique is defined by the following equation:

`Xn+1 = (aXn + c) mod m`

In this equation, `Xn`

is the current value, `Xn+1`

is the next value, a is the multiplier, `c`

is the increment, and `m`

is the modulus.

To use this technique, the values of `a`

, `c`

, and `m`

must be chosen. The value of a should be chosen to be relatively prime to `m`

. The value of `c`

should be chosen to be 0 or relatively prime to `m`

. The value of `m`

should be a power of two.

#### Technique 4: Use a Universal Hash Function

Another technique that can be used to improve the performance of hash tables is to use a universal hash function. A universal hash function is a mathematical function that is used to map a set of keys to a set of values. The use of a universal hash function can help to improve the performance of hash tables because it can help to avoid certain types of collisions.

A universal hash function is defined by the following equation:

`h(x) = ((ax + b) mod p) mod m`

In this equation, `x`

is the input value, `h(x)`

is the output value, `a`

and `b`

are integers, `p`

is a prime number, and `m`

is the number of slots in the hash table.

To use this technique, the values of `a`

, `b`

, and `p`

must be chosen. The value of a should be chosen to be relatively prime to `p`

. The value of `b`

can be any integer. The value of `p`

should be a prime number.

However, there are a few problems with using the modulus operator as a hash function. Firstly, it is not very uniform. For example, if our keys are all odd numbers, then all of our values will be stored in bucket 1.

Secondly, it is not very deterministic. This means that if we insert the same key twice, we are not guaranteed to get the same index. This can lead to problems if we need to update or delete a specific key.

## Hashing with chaining

To overcome these problems, we can use a technique called hashing with chaining. This is where each bucket is itself a linked list of key/value pairs. When we want to insert a new key/value pair, we first compute the index using our hash function. We then search the linked list at that index to see if the key already exists.

If it does, we update the value associated with that key. If it doesn't, we add the new key/value pair to the linked list.

A hash table uses chaining to resolve collisions. A collision is when two keys are mapped to the same value. Chaining is a technique that is used to resolve collisions. Chaining is a technique that links keys that map to the same value together in a linked list.

The main advantage of this technique is that it is very uniform. Every key will be hashed to an index in the range of 0-9, regardless of the value of the key.

The main disadvantage is that it is not very efficient. If our hash table is large, and we have a lot of collisions (keys that hash to the same index), then our linked lists will become very long and searching for a specific key will take a long time.

Here is an example of hashing with chaining algorithm

- Input: Key, Value
- Output: Hash Table
- HashTable HashTable(Key, Value)
- HashFunction := HashFunction(Key)
- if HashTable[HashFunction] == NULL then
- HashTable[HashFunction] := LinkedList()
- endif
- HashTable[HashFunction].Insert(Value)
- end HashTable

The following is the pseudocode for the lookup operation:

- Input: Key, Hash Table
- Output: Value
- Value Lookup(Key, HashTable)
- HashFunction := HashFunction(Key)
- if HashTable[HashFunction] != NULL then
- return HashTable[HashFunction].Search(Value)
- else
- return NULL
- endif
- end Lookup

### Complexity Analysis

The time complexity of the hashing with the chaining technique is O(1). The time complexity of the lookup operation is O(1).

The space complexity of the hashing with chaining technique is O(n). The space complexity of the lookup operation is O(1).

There are a few other techniques that can be used to improve the efficiency of hash tables. These include:

## Open Addressing

Open Addressing: This is where we try to find an empty bucket if a collision occurs. We can do this by linear probing, quadratic probing or double hashing.

## Separate Chaining

Separate Chaining: This is where we store each key in a separate linked list. This allows us to store more keys in the same bucket, without the need for long linked lists.

## Rehashing

Rehashing: This is where we resize the hash table and rehash all of the keys. This can be done when the table becomes full, or when the number of collisions becomes too high.

Hash tables are a very important data structure, and there are a number of different techniques that can be used to improve their performance. By using the right technique for your specific application, you can ensure that your hash table is efficient and effective.

#2Articles1Week