# Hash Table vs Trie

### What is Hash Table?

An array that stores pointers to records corresponding to a given element. An entry in the hash table is NIL if no existing element has a hash function value equal to the index for the entry. In simple terms, we can say that a hash table is a generalization of the array. Hash table gives the functionality in which a collection of data is stored in such a way that it is easy to find those items later if required. This makes searching for an element very efficient.

### Advantages of Hash Table over Trie:

- Easy to implement and understand.
- Hash provides better synchronization than other data structures.
- Hash tables are more efficient than search trees or other data structures.
- Hash provides constant time for searching, insertion, and deletion operations on average.
- The system will already have a well-optimized implementation faster than tries for most purposes.
- Keys need not have any special structure.
- More space-efficient than the obviously linked trie structure

### Disadvantages of Hash Table over Trie:

- Hash is inefficient when there are many collisions.
- Hash collisions are practically not be avoided for a large set of possible keys.
- Hash does not allow null values.

### Applications of Hash Table:

- Hash is used in databases for indexing.
- Hash is used in disk-based data structures.
- In some programming languages like Python, JavaScript hash is used to implement objects.
- Hash is used for cache mapping for fast access to the data.
- Hash can be used for password verification.
- Hash is used in cryptography as a message digest.:

**Complexity analysis of Hash Table:**

- Time for Insertion:
**O(1**) - Time for Deletion:
**O(1)** - Time for Searching:
**O(1)**

### What is Trie?

Trie data structure is defined as a Tree based data structure that is used for storing some collection of strings and performing efficient search operations on them. The word Trie is derived from retrieval, which means finding something or obtaining it.

Trie follows some property that If two strings have a common prefix then they will have the same ancestor in the trie. A trie can be used to sort a collection of strings alphabetically as well as search whether a string with a given prefix is present in the trie or not.

### Advantages of Trie over Hash Table:

- Predictable O(n) lookup time where n is the size of the key
- Lookup can take less than n time if it’s not there
- Supports ordered traversal
- No need for a hash function
- Deletion is straightforward
- You can quickly look up prefixes of keys, enumerate all entries with a given prefix, etc
- We can efficiently do prefix search (or auto-complete) with Trie.
- We can easily print all words in alphabetical order which is not easily possible with hashing.
- There is no overhead of Hash functions in a Trie data structure.
- Searching for a String even in the large collection of strings in a Trie data structure can be done in O(L) Time complexity, Where L is the number of words in the query string. This searching time could be even less than O(L) if the query string does not exist in the trie.

### Disadvantages of Trie over Hash Table:

- The main disadvantage of the trie is that it takes a lot of memory to store all the strings. For each node, we have too many node pointers which are equal to the no of characters in the worst case.
- An efficiently constructed hash table(i.e. a good hash function and a reasonable load factor) has O(1) as lookup time which is way faster than O(l) in the case of a trie, where l is the length of the string.

### Applications of Trie:

- Autocomplete Feature: Autocomplete provides suggestions based on what you type in the search box. Trie data structure is used to implement autocomplete functionality.
- Spell Checkers: If the word typed does not appear in the dictionary, then it shows suggestions based on what you typed.

It is a 3-step process that includes :- Checking for the word in the data dictionary.
- Generating potential suggestions.
- Sorting the suggestions with higher priority on top.

- Trie stores the data dictionary and makes it easier to build an algorithm for searching the word from the dictionary and provides the list of valid words for the suggestion.
- Longest Prefix Matching Algorithm(Maximum Prefix Length Match): This algorithm is used in networking by the routing devices in IP networking. Optimization of network routes requires contiguous masking that bound the complexity of lookup a time to O(n), where n is the length of the URL address in bits. To speed up the lookup process, Multiple Bit trie schemes were developed that perform the lookups of multiple bits faster.

**Complexity analysis of Trie:**

- Time for Insertion: O(N)
- Time for Deletion: O(N)
- Time for Searching: O(N)

### Compare the Lookup operation of HashTable vs Trie:

**HashTable**:

- An efficiently constructed hash table(i.e. a good hash function and a reasonable load factor) has O(1) as a lookup.
- It always takes the same time and does not care about whether the element is present or not.
- It is faster than Trie.
- It is not predictable.

**Trie**:

- Trie has a lookup time of O(n) where n is the size of the key.
- Lookup can take less than n time if it’s not there.
- It is slower than HashTable.
- It is predictable.

## Please

Loginto comment...