Prefix Search Using Trie in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Trie Insert and Search

What is the output of the following C++ code that inserts words into a Trie and searches for a prefix?

DSA C++

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

class TrieNode {
public:
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord;
    TrieNode() : isEndOfWord(false) {}
};

class Trie {
private:
    TrieNode* root;
public:
    Trie() { root = new TrieNode(); }
    void insert(const string& word) {
        TrieNode* node = root;
        for (char c : word) {
            if (!node->children.count(c)) {
                node->children[c] = new TrieNode();
            }
            node = node->children[c];
        }
        node->isEndOfWord = true;
    }
    bool startsWith(const string& prefix) {
        TrieNode* node = root;
        for (char c : prefix) {
            if (!node->children.count(c)) return false;
            node = node->children[c];
        }
        return true;
    }
};

int main() {
    Trie trie;
    trie.insert("apple");
    trie.insert("app");
    cout << boolalpha << trie.startsWith("app") << endl;
    cout << boolalpha << trie.startsWith("apl") << endl;
    return 0;
}

A

true
true

B

true
false

C

false
false

D

false
true

💡 Hint

Think about whether the prefix "app" and "apl" exist in the inserted words.

The prefix "app" exists because both "apple" and "app" start with "app".

The prefix "apl" does not exist in the Trie because no inserted word starts with "apl".

🧠 Conceptual

intermediate

Number of Nodes in Trie After Insertions

If you insert the words ["cat", "car", "cart"] into an empty Trie, how many nodes will the Trie contain (including the root)?

A 10

B 8

C 9

D 7

💡 Hint

Count shared prefixes carefully to avoid double counting nodes.

Root node counts as 1.

Words share prefixes: "cat", "car", "cart" share 'c' and 'a' and 'r' nodes.

Counting nodes: root(1), c(2), a(3), t(4), r(5), t(6).

🔧 Debug

advanced

Identify the Error in Trie Search Function

What error will the following C++ Trie search function cause when searching for a prefix that does not exist?

DSA C++

bool startsWith(const string& prefix) {
    TrieNode* node = root;
    for (char c : prefix) {
        node = node->children[c];
        if (!node) return false;
    }
    return true;
}

A Runtime error: accessing non-existent key in unordered_map

B Returns false correctly without error

C Compilation error due to missing return statement

D Always returns true regardless of prefix

💡 Hint

Check how unordered_map operator[] behaves when key is missing.

Using operator[] on unordered_map with a missing key inserts a new node, so node is never null.

Then dereferencing node->children[c] when node is null causes runtime error.

🚀 Application

advanced

Find All Words With Given Prefix

Given a Trie with words inserted, which approach correctly finds all words starting with a given prefix?

A Traverse Trie to prefix node, then DFS to collect all words from there

B Check each word in the Trie root's children for prefix match

C Store all words in a list and filter by prefix each time

D Use BFS from root and stop at first prefix match

💡 Hint

Think about efficient traversal starting from the prefix node.

Option A is correct because it efficiently finds the prefix node and explores all descendants.

Other options are inefficient or incorrect.

❓ Predict Output

expert

Output of Trie Prefix Search with Multiple Insertions

What is the output of the following C++ code that inserts multiple words and checks prefixes?

DSA C++

#include <iostream>
#include <unordered_map>
#include <string>
#include <vector>
using namespace std;

class TrieNode {
public:
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord;
    TrieNode() : isEndOfWord(false) {}
};

class Trie {
private:
    TrieNode* root;
    void dfs(TrieNode* node, string current, vector<string>& results) {
        if (node->isEndOfWord) results.push_back(current);
        for (auto& pair : node->children) {
            dfs(pair.second, current + pair.first, results);
        }
    }
public:
    Trie() { root = new TrieNode(); }
    void insert(const string& word) {
        TrieNode* node = root;
        for (char c : word) {
            if (!node->children.count(c)) {
                node->children[c] = new TrieNode();
            }
            node = node->children[c];
        }
        node->isEndOfWord = true;
    }
    vector<string> findWordsWithPrefix(const string& prefix) {
        TrieNode* node = root;
        for (char c : prefix) {
            if (!node->children.count(c)) return {};
            node = node->children[c];
        }
        vector<string> results;
        dfs(node, prefix, results);
        return results;
    }
};

int main() {
    Trie trie;
    trie.insert("test");
    trie.insert("team");
    trie.insert("teach");
    trie.insert("toast");
    vector<string> words = trie.findWordsWithPrefix("te");
    for (const string& w : words) {
        cout << w << " ";
    }
    cout << endl;
    return 0;
}

A test teach team

B teach team test

C team teach test

D test team teach

💡 Hint

The DFS visits children in order of insertion in unordered_map, which is not ordered, but assume insertion order for this question.

The DFS visits children in the order they were inserted: 's' for test, 'a' for team and teach.

So words collected are "test", "team", "teach" in that order.