Implement Trie II (Prefix Tree) - Practice Coding Problems

Implement Trie II (Prefix Tree) - Problem

A Trie (pronounced as "try") or prefix tree is a tree data structure that efficiently stores and retrieves keys in a dataset of strings. Think of it as a digital dictionary that can instantly tell you not just if a word exists, but also how many times it appears and how many words start with a given prefix!

This enhanced version of the classic Trie supports:

insert(word) - Add a word to the trie (can be added multiple times)
countWordsEqualTo(word) - Count how many instances of this exact word exist
countWordsStartingWith(prefix) - Count how many words start with this prefix
erase(word) - Remove one instance of this word from the trie

Real-world applications: Autocomplete systems (like Google Search), spell checkers, word frequency analyzers, and search engines all rely on similar data structures!

Input & Output

example_1.py — Basic Operations

$ Input: trie = Trie() trie.insert("apple") trie.insert("apple") trie.countWordsEqualTo("apple") // return 2 trie.countWordsStartingWith("app") // return 2 trie.erase("apple") trie.countWordsEqualTo("apple") // return 1

› Output: 2, 2, 1

💡 Note: We insert "apple" twice, so countWordsEqualTo returns 2. Both instances start with "app", so countWordsStartingWith returns 2. After erasing once, only 1 instance remains.

example_2.py — Prefix Counting

$ Input: trie = Trie() trie.insert("car") trie.insert("card") trie.insert("care") trie.insert("cat") trie.countWordsStartingWith("car") // return 3 trie.countWordsStartingWith("ca") // return 4

› Output: 3, 4

💡 Note: Three words start with "car" (car, card, care), and four words start with "ca" (all of them including cat).

example_3.py — Edge Cases

$ Input: trie = Trie() trie.countWordsEqualTo("missing") // return 0 trie.countWordsStartingWith("x") // return 0 trie.erase("nonexistent") // no effect trie.insert("a") trie.erase("a") trie.countWordsEqualTo("a") // return 0

› Output: 0, 0, 0

💡 Note: Querying non-existent words returns 0. Erasing non-existent words has no effect. After inserting and erasing "a", the count becomes 0.

Constraints

1 ≤ word.length, prefix.length ≤ 2000
word and prefix consist only of lowercase English letters
At most 3 × 10⁴ calls in total will be made to insert, countWordsEqualTo, countWordsStartingWith, and erase
It is guaranteed that for any function call to erase, the word will exist in the trie

Visualization

Tap to expand

Understanding the Visualization

Initialize Empty Trie

Start with root node containing empty counters

Insert 'car'

Create path c→a→r, increment prefix counts along path, set word count at end

Insert 'card'

Reuse existing c→a→r path, extend with 'd', update all counters

Query prefix 'car'

Navigate to 'r' node and return its prefix count

Key Takeaway

🎯 Key Insight: By storing word count and prefix count at each node, the Trie enables O(m) operations instead of O(n×m) linear search, making it highly efficient for prefix-based queries.

Asked in

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

The optimal solution uses a Trie (prefix tree) data structure where each node contains two counters: word count (words ending at this node) and prefix count (words passing through this node). This enables O(m) time complexity for all operations, where m is the word/prefix length, making it highly efficient for string prefix operations.

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 search linearly for each operation
Optimal Trie Implementation	O(m)	O(ALPHABET_SIZE × N × M)	Build a proper trie with nodes containing word counts and prefix counts

Brute Force (Array/List Storage) — Algorithm Steps

Store all inserted words in a dynamic array/list
For countWordsEqualTo: iterate through list and count exact matches
For countWordsStartingWith: iterate through list and count words with matching prefix
For erase: find first occurrence and remove it from the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Words

All words stored in simple array

Linear Search

Scan entire array for each query

Count Matches

Count words that match criteria

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_WORDS 10000
#define MAX_LEN 100

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

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

void trieInsert(Trie* obj, char* word) {
    strcpy(obj->words[obj->count++], word);
}

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

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

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n is number of stored words, m is average word length. Each operation scans all words.

✓ Linear Growth

Space Complexity

O(n × m)

Store all words explicitly, including duplicates

⚡ Linearithmic Space

42.0K Views

High Frequency

~25 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Array/List Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler