Implement Trie (Prefix Tree) - Practice Coding Problems

Implement Trie (Prefix Tree) - Problem

A trie (pronounced as "try") or prefix tree is a specialized tree data structure that efficiently stores and retrieves strings. Think of it as a digital dictionary where each path from root to node represents a sequence of characters.

Tries are incredibly useful for applications like:

Autocomplete systems (like Google search suggestions)
Spell checkers (finding words with common prefixes)
IP routing (longest prefix matching)
T9 predictive text

Your task is to implement a Trie class with these core operations:

Trie() - Initialize an empty trie
insert(word) - Add a word to the trie
search(word) - Check if a complete word exists
startsWith(prefix) - Check if any word starts with the given prefix

Example: After inserting "cat", "cats", and "dog", searching for "cat" returns true, but searching for "ca" returns false. However, startsWith("ca") returns true because "cat" and "cats" start with "ca".

Input & Output

basic_operations.py — Python

$ Input: trie = Trie() trie.insert("apple") trie.search("apple") # True trie.search("app") # False trie.startsWith("app") # True trie.insert("app") trie.search("app") # True

› Output: True False True True

💡 Note: After inserting "apple", searching for the complete word returns True, but "app" returns False since it wasn't inserted as a complete word. However, startsWith("app") returns True because "apple" starts with "app". After inserting "app", searching for "app" now returns True.

multiple_words.py — Python

$ Input: trie = Trie() trie.insert("car") trie.insert("card") trie.insert("care") trie.insert("careful") trie.search("car") # True trie.search("card") # True trie.startsWith("care") # True trie.search("caring") # False

› Output: True True True False

💡 Note: Multiple words with common prefixes are efficiently stored. All inserted words can be found, prefixes match appropriately, but words that weren't inserted (like "caring") return False even if they share prefixes with inserted words.

edge_cases.py — Python

$ Input: trie = Trie() trie.search("") # False (empty not inserted) trie.startsWith("") # True (empty prefix matches all) trie.insert("") trie.search("") # True (now empty is inserted) trie.insert("a") trie.startsWith("ab") # False (no words start with "ab")

› Output: False True True False

💡 Note: Edge case handling: empty string as word vs. prefix, and checking prefixes that don't exist in the trie. Empty prefix technically matches all words (including none), but empty word needs to be explicitly inserted to be found.

Visualization

Tap to expand

Understanding the Visualization

Empty Trie

Start with just the root node

Insert "cat"

Create path: root → c → a → t (mark as word end)

Insert "cats"

Reuse existing "cat" path, add 's' and mark end

Insert "car"

Reuse 'c' → 'a', branch to 'r' and mark end

Search "cat"

Follow path and verify end marker exists

Key Takeaway

🎯 Key Insight: Tries excel at storing strings with common prefixes by sharing nodes for identical character sequences, making them perfect for autocomplete, spell checkers, and dictionary applications.

Time & Space Complexity

Time Complexity

⏱️

O(m)

Where m is the length of the word/prefix. Each operation traverses at most m nodes in the tree.

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE * N * M)

In worst case, where N is number of words, M is average length, and ALPHABET_SIZE is typically 26 for lowercase letters. Common prefixes are shared.

✓ Linear Space

Constraints

1 ≤ word.length, prefix.length ≤ 2000
word and prefix consist of only lowercase English letters
At most 3 × 10⁴ calls will be made to insert, search, and startsWith
All input strings are non-empty for insert and search operations

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a Trie (prefix tree) data structure where each node represents a character and contains references to child nodes. This achieves O(m) time complexity for all operations where m is the word/prefix length, making it highly efficient for string storage and retrieval with shared prefixes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Array/List Storage)	O(n*m)	O(n*m)	Store all words in a simple array and linear search for operations
Trie Data Structure (Optimal)	O(m)	O(ALPHABET_SIZE * N * M)	Build a tree where each node represents a character, enabling O(m) operations

Brute Force (Array/List Storage) — Algorithm Steps

Store all inserted words in an array/list
For search: iterate through all words to find exact match
For startsWith: iterate through all words to check prefix match
Return appropriate boolean results

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert words

Add words to array: ["apple", "app", "apricot"]

Search operation

Scan entire array to find exact match

Prefix operation

Check each word to see if it starts with prefix

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100

typedef struct {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int count;
} Trie;

Trie* trieCreate() {
    Trie* trie = (Trie*)malloc(sizeof(Trie));
    trie->count = 0;
    return trie;
}

void trieInsert(Trie* obj, char* word) {
    for (int i = 0; i < obj->count; i++) {
        if (strcmp(obj->words[i], word) == 0) {
            return;
        }
    }
    strcpy(obj->words[obj->count], word);
    obj->count++;
}

bool trieSearch(Trie* obj, char* word) {
    for (int i = 0; i < obj->count; i++) {
        if (strcmp(obj->words[i], word) == 0) {
            return true;
        }
    }
    return false;
}

bool trieStartsWith(Trie* obj, char* prefix) {
    int prefixLen = strlen(prefix);
    for (int i = 0; i < obj->count; i++) {
        if (strncmp(obj->words[i], prefix, prefixLen) == 0) {
            return true;
        }
    }
    return false;
}

void trieFree(Trie* obj) {
    free(obj);
}

// Example usage
int main() {
    Trie* trie = trieCreate();
    trieInsert(trie, "apple");
    printf("%d\n", trieSearch(trie, "app"));     // 0 (false)
    printf("%d\n", trieSearch(trie, "apple"));   // 1 (true)
    printf("%d\n", trieStartsWith(trie, "app")); // 1 (true)
    trieFree(trie);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

Where n is the number of words and m is average word length. Each operation requires scanning all words.

✓ Linear Growth

Space Complexity

O(n*m)

Storage for all n words with average length m, no sharing of common prefixes.

⚡ Linearithmic Space

Constraints

1 ≤ word.length, prefix.length ≤ 2000
word and prefix consist of only lowercase English letters
At most 3 × 10⁴ calls will be made to insert, search, and startsWith
All input strings are non-empty for insert and search operations

425.0K Views

High Frequency

~25 min Avg. Time

8.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Array/List Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler