# What Is Trie Data Structure With Example?

//

Larry Thompson

A Trie, also known as a prefix tree, is a specialized data structure that is particularly useful when dealing with problems related to strings or words. It allows for efficient searching, insertion, and deletion operations on a large set of strings. In this article, we will delve into the details of Trie data structure and provide examples to illustrate its functionality.

What is a Trie?
A Trie is a tree-like data structure that stores strings by breaking them down into individual characters or letters. Each node in the Trie represents a single character and can have multiple child nodes representing the subsequent characters in the string. The root node represents an empty string or the start of the word.

Example:
Consider we have a set of words: “apple”, “apply”, “banana”, “band”, “bat”. To represent these words in a Trie, we would start with an empty root node and create child nodes for each character in the words.

## Trie Structure:

To visualize the Trie structure for our example words, let’s represent each character as a node using HTML unordered lists (

) and list items (

• ). The root node will be represented by an empty list item:
• a
• b

The first level of child nodes represents the possible starting characters in our word set – ‘a’ and ‘b’. Under each starting character, we continue creating child nodes to represent subsequent characters. Let’s add more nodes to our Trie representation:

• a
• p
• p
• l
• e
• l
• y
• b
• a
• n
• d
• t

In this Trie structure, we can see that the words “apple” and “apply” share a common prefix, which is represented by the nodes ‘a’, ‘p’, and ‘p’. Similarly, the words “banana”, “band”, and “bat” share the common prefix ‘b’, ‘a’, and ‘n’.

## Key Operations on Trie:

1. Insertion: To insert a word into a Trie, we start from the root node and traverse down through each character of the word.

If a node representing that character already exists, we move to the next character. Otherwise, we create a new node for that character. After inserting all characters of the word, we mark the last node as an end-of-word node.

2. Search: To search for a word in a Trie, we start from the root node and traverse down through each character of the word. If at any point a required node is not found or we reach the end of the word without finding an end-of-word marker, it means that the word is not present in the Trie.

3. Deletion: Deleting a word from a Trie involves removing all the nodes associated with that word.

If, after deleting a node, its parent node becomes useless (no other child nodes and not an end-of-word marker), we can recursively delete the parent node as well. This process continues until we reach a parent node that is still useful or the root node.

Trie data structure offers several advantages in comparison to other data structures when dealing with string-related problems:

• Efficient Prefix Searching: Trie allows for efficient prefix searching, making it ideal for autocomplete features or dictionary-like applications.
• Space Optimization: Trie optimizes space by sharing common prefixes among words, resulting in efficient storage of large sets of strings.
• Fast Insertion and Lookup: The time complexity for insertion and lookup in a Trie is O(M), where M represents the length of the word being inserted or searched.

## Conclusion:

In this article, we explored the Trie data structure and its functionality. We discussed how Trie stores strings efficiently by breaking them down into individual characters represented by nodes.

We also covered key operations such as insertion, search, and deletion in a Trie. Finally, we highlighted some advantages of using Trie when dealing with string-related problems.

Trie is a powerful data structure that finds applications in various domains such as spell-checking systems, search engines, network routers, and more. By understanding its working principles and benefits, you can leverage Trie to improve the efficiency and performance of your own applications.