A Trie, also known as a prefix tree, is a special type of tree used to store associative data structures. It's a fundamental data structure that provides a clever mechanism for efficiently managing sets of strings, often used in tasks like autocomplete, spell checking, and IP routing. To understand a Trie, let's break down the concept into its basic principles:

Basic Principles of Trie

  1. Tree Structure: Like any tree, a Trie has nodes and edges. Each node (except the root) is associated with a character. The root node is usually an empty node.

  2. Path as Key: In a Trie, each path from the root to a node represents a key or a part of it. This key is formed by concatenating the characters along the path.

  3. Common Prefix Sharing: Trie allows the keys with common prefixes to share the same nodes up to the point where their paths diverge. This makes Tries highly space-efficient when dealing with large sets of strings that share prefixes.

  4. End of Word Marker: To mark the end of a word, Tries often use a special marker or flag. This is because a word's characters might be a prefix of another word. For instance, "bat" is a prefix of "batch".


  • Space Efficiency: Since common prefixes are shared, Tries can be space-efficient when storing large sets of strings.
  • Search Time Complexity: Tries offer a fixed time lookup, which is O(m), where m is the length of the string to search. This efficiency is not affected by the number of keys stored.


  • Space Overhead: Each node might require more space because it has to store pointers to its children.
  • Long Strings with Different Prefixes: If the set of strings has very long words with different prefixes, the Trie can become deep and consume more space.


  • Autocomplete and Spell Checkers: Common in text editors and search engines.
  • IP Routing: Efficiently find longest prefix match.
  • Bioinformatics: Used for tasks like genome analysis.

Implementation Basics

A basic Trie node might look like this in Python:

class TrieNode:
    def __init__(self):
        self.children = {}  # Dictionary to hold child nodes
        self.isEndOfWord = False  # Flag to mark the end of a word

The Trie itself can be represented as:

class Trie:
    def __init__(self):
        self.root = TrieNode()  # The root node is empty

    def insert(self, word):
        node = self.root
        for char in word:
            # For each character, check if it's already in the children
            if char not in node.children:
                node.children[char] = TrieNode()  # Create a new node if not found
            node = node.children[char]  # Move to the child node
        node.isEndOfWord = True  # Mark the end of a word

    def search(self, word):
        node = self.root
        for char in word:
            # Traverse the Trie with the characters of the word
            if char not in node.children:
                return False  # If a character is missing, the word isn't present
            node = node.children[char]
        return node.isEndOfWord  # Return True if we reach the end of a word

In this implementation:

  • Each TrieNode has a dictionary of children and a flag to mark the end of a word.
  • The Trie class has methods to insert and search for words.
  • Insertion involves creating new nodes for characters not already in the Trie.
  • Searching involves traversing the Trie with the characters of the word.

This basic understanding and implementation outline the core concepts of Tries and their practical applications.