Word Search in Trie in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Trie data structure?

A Trie is a tree-like data structure used to store a dynamic set of strings where keys are usually strings. Each node represents a character, and paths from root to leaves represent words.

beginner

How does a Trie help in word search?

A Trie allows fast prefix-based search by traversing nodes corresponding to characters of the word. It can quickly check if a word or prefix exists by following the path in the Trie.

intermediate

What is the time complexity of searching a word in a Trie?

The time complexity is O(m), where m is the length of the word being searched, because we check one character at each level of the Trie.

beginner

Explain how to insert a word into a Trie.

Start from the root node. For each character in the word, check if a child node exists. If not, create a new node. Move to the child node and continue. Mark the last node as the end of a word.

beginner

What does it mean if a node in a Trie is marked as 'end of word'?

It means that the path from the root to this node forms a complete valid word stored in the Trie.

What does each node in a Trie represent?

A A character of a word

B A whole word

C An integer value

D A number of words

Each node in a Trie represents a single character of a word.

What is the main advantage of using a Trie for word search?

A Uses less memory than arrays

B Fast prefix search

C Stores numbers efficiently

D Sorts words automatically

Trie allows fast prefix-based search by traversing nodes corresponding to characters.

What is the time complexity to search a word of length m in a Trie?

A O(m)

B O(1)

C O(log m)

D O(m^2)

Searching a word in a Trie takes O(m) time, where m is the word length.

When inserting a word into a Trie, what do you do if a character node does not exist?

A Skip the character

B Delete the Trie

C Replace the root node

D Create a new node for that character

If a character node does not exist, create a new node for it.

What does marking a node as 'end of word' signify in a Trie?

A The node is empty

B The node is the root

C The path to this node forms a complete word

D The node has no children

Marking a node as 'end of word' means the path from root to this node forms a valid word.

Describe how to search for a word in a Trie step-by-step.

Think about following the path of characters from root to leaf.

Explain why Tries are efficient for prefix-based word searches.

Consider how words with same start share parts of the Trie.

Practice

1. What is the main purpose of using a Trie data structure in word search problems?

easy

A. To store words in a linked list

B. To sort words alphabetically

C. To efficiently store and search words by their prefixes

D. To perform arithmetic operations on words

Solution

1. Step 1: Understand Trie structure

   A Trie stores characters of words in a tree where each node represents a character, allowing prefix sharing.

2. Step 2: Identify Trie use in word search

   Because words share prefixes, Trie allows fast prefix-based search, making word search efficient.

3. Final Answer:

   To efficiently store and search words by their prefixes -> Option C

4. Quick Check:

   Trie = prefix search [OK]

Hint: Trie is best for prefix-based word search [OK]

Common Mistakes:

• Confusing Trie with sorting structures
• Thinking Trie stores words linearly
• Assuming Trie is for arithmetic

2. Which of the following is the correct way to declare a Trie node class in C++ for word search?

easy

A. class TrieNode { public: TrieNode* children[26]; bool isEndOfWord; };

B. class TrieNode { int data; TrieNode* next; };

C. struct TrieNode { vector<int> children; bool end; };

D. class TrieNode { char letter; TrieNode* left; TrieNode* right; };

Solution

1. Step 1: Check Trie node structure for word search

   Trie nodes typically have an array of pointers for 26 letters and a boolean to mark word end.

2. Step 2: Match with options

   class TrieNode { public: TrieNode* children[26]; bool isEndOfWord; }; matches this structure exactly with children array and isEndOfWord flag.

3. Final Answer:

   class TrieNode { public: TrieNode* children[26]; bool isEndOfWord; }; -> Option A

4. Quick Check:

   Trie node = children array + end flag [OK]

Hint: Trie nodes have 26 children pointers and end flag [OK]

Common Mistakes:

• Using linked list pointers instead of array
• Using vector<int> instead of pointers
• Confusing binary tree node with Trie node

3. What will be the output of the following C++ code snippet that inserts words into a Trie and searches for "cat"?

class TrieNode {
public:
    TrieNode* children[26] = {nullptr};
    bool isEndOfWord = false;
};

class Trie {
public:
    TrieNode* root;
    Trie() { root = new TrieNode(); }
    void insert(string word) {
        TrieNode* node = root;
        for (char c : word) {
            int index = c - 'a';
            if (!node->children[index])
                node->children[index] = new TrieNode();
            node = node->children[index];
        }
        node->isEndOfWord = true;
    }
    bool search(string word) {
        TrieNode* node = root;
        for (char c : word) {
            int index = c - 'a';
            if (!node->children[index])
                return false;
            node = node->children[index];
        }
        return node->isEndOfWord;
    }
};

int main() {
    Trie trie;
    trie.insert("cat");
    trie.insert("car");
    trie.insert("dog");
    cout << (trie.search("cat") ? "Found" : "Not Found") << endl;
    return 0;
}

medium

A. Runtime Error

B. Found

C. Compilation Error

D. Not Found

Solution

1. Step 1: Insert words "cat", "car", "dog" into Trie

   Each word is inserted character by character, creating nodes and marking end of word for last character.

2. Step 2: Search for "cat" in Trie

   Traversal finds nodes for 'c', 'a', 't' and confirms isEndOfWord is true, so returns true.

3. Final Answer:

   Found -> Option B

4. Quick Check:

   Inserted word found = Found [OK]

Hint: Search returns true if end flag is set after traversal [OK]

Common Mistakes:

• Not marking isEndOfWord true on insert
• Returning true without checking end flag
• Off-by-one errors in indexing

4. Identify the bug in the following Trie search function and select the correct fix:

bool search(string word) {
    TrieNode* node = root;
    for (char c : word) {
        int index = c - 'a';
        if (node->children[index])
            return false;
        node = node->children[index];
    }
    return node->isEndOfWord;
}

medium

A. Add a check for null root pointer before loop

B. Remove the return statement inside the loop

C. Change 'node = node->children[index];' to 'node = node->children[index + 1];'

D. Change 'if (node->children[index])' to 'if (!node->children[index])'

Solution

1. Step 1: Analyze the if condition inside loop

   The condition 'if (node->children[index]) return false;' wrongly returns false if child exists, which is opposite logic.

2. Step 2: Correct the condition to check if child does NOT exist

   It should be 'if (!node->children[index]) return false;' to return false when path breaks.

3. Final Answer:

   Change 'if (node->children[index])' to 'if (!node->children[index])' -> Option D

4. Quick Check:

   Check for missing child = return false [OK]

Hint: Return false if child node is missing, not if present [OK]

Common Mistakes:

• Returning false when child exists
• Ignoring null pointer checks
• Incorrect index calculation

5. Given a list of words: ["apple", "app", "application", "bat", "bath", "batman"], how can a Trie be used to efficiently find all words starting with the prefix "app"? Choose the best approach.

hard

A. Insert all words into Trie, then traverse nodes for 'a'->'p'->'p' and collect all descendant words

B. Sort the list and perform binary search for prefix "app"

C. Use a hash map to store all words and check prefix by substring

D. Store words in a linked list and scan each word for prefix match

Solution

1. Step 1: Insert all words into Trie

   Each word is inserted character by character, building a prefix tree.

2. Step 2: Traverse Trie nodes for prefix "app"

   Follow nodes for 'a', 'p', 'p' to reach prefix node, then collect all words below it.

3. Step 3: Collect descendant words

   Perform DFS or BFS from prefix node to gather all words starting with "app" efficiently.

4. Final Answer:

   Insert all words into Trie, then traverse nodes for 'a'->'p'->'p' and collect all descendant words -> Option A

5. Quick Check:

   Trie prefix traversal + collect descendants = Insert all words into Trie, then traverse nodes for 'a'->'p'->'p' and collect all descendant words [OK]

Hint: Traverse prefix nodes then gather descendants in Trie [OK]

Common Mistakes:

• Using sorting instead of Trie for prefix search
• Checking prefix by substring on all words
• Scanning linked list inefficiently