Prefix Search Using Trie in DSA Java - 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 down the tree represent words or prefixes.

beginner

How does a Trie help in prefix search?

A Trie allows quick prefix search by traversing nodes corresponding to each character of the prefix. If traversal succeeds, all words under that node share the prefix.

beginner

What is stored in each node of a Trie?

Each node stores links to child nodes for possible characters and a boolean flag indicating if the node marks the end of a valid word.

intermediate

Describe the steps to insert a word into a Trie.

Start at the root. For each character in the word, check if a child node exists. If not, create it. Move to the child node. After the last character, mark the node as end of word.

intermediate

How to retrieve all words with a given prefix in a Trie?

Traverse the Trie nodes for the prefix. From the last prefix node, perform a depth-first search to collect all words that have that prefix.

What does each node in a Trie typically represent?

A A character

B A whole word

C An integer value

D A prefix length

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

What is the time complexity to search a prefix of length k in a Trie?

A O(log n)

B O(n)

C O(k)

D O(k^2)

Searching a prefix of length k requires traversing k nodes, so time complexity is O(k).

Which of these is NOT a typical use case of a Trie?

A Sorting numbers

B Spell checking

C Prefix search

D Autocomplete

Tries are not used for sorting numbers; they are mainly for string prefix operations.

What flag is used in Trie nodes to indicate a complete word?

A isPrefix

B isWordEnd

C isRoot

D isLeaf

The isWordEnd flag marks that the path to this node forms a complete word.

To find all words with a prefix, what traversal is used after reaching the prefix node?

A Linear search

B Breadth-first search

C Binary search

D Depth-first search

Depth-first search is used to explore all child nodes to collect words with the prefix.

Explain how to insert a word into a Trie and how it helps in prefix search.

Think about how each character leads to a node and how prefixes share nodes.

Describe the process to find all words starting with a given prefix using a Trie.

Focus on the two-step process: locating prefix and exploring descendants.

Practice

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

easy

A. To efficiently find all words that start with a given prefix

B. To sort words alphabetically

C. To store numbers in sorted order

D. To perform arithmetic operations quickly

Solution

1. Step 1: Understand what prefix search means

   Prefix search means finding all words that start with a certain beginning sequence of letters.

2. Step 2: Understand Trie's role in prefix search

   A Trie stores words in a tree where each node represents a letter, making it easy to find all words sharing the same prefix by traversing the tree.

3. Final Answer:

   To efficiently find all words that start with a given prefix -> Option A

4. Quick Check:

   Prefix search = efficient word lookup [OK]

Hint: Trie nodes represent letters for fast prefix lookup [OK]

Common Mistakes:

• Confusing Trie with sorting data structures
• Thinking Trie is for arithmetic operations
• Assuming Trie stores numbers only

2. Which of the following is the correct way to declare a Trie node class in Java?

easy

A. class TrieNode { int[] children = new int[26]; boolean isEndOfWord; }

B. class TrieNode { char[] children = new char[26]; boolean isEndOfWord; }

C. class TrieNode { String[] children = new String[26]; boolean isEndOfWord; }

D. class TrieNode { TrieNode[] children = new TrieNode[26]; boolean isEndOfWord; }

Solution

1. Step 1: Identify the correct type for children nodes

   Each child should be a reference to another TrieNode, so the array type must be TrieNode[].

2. Step 2: Check the other parts of the class

   Boolean isEndOfWord marks if the node ends a word, which is correct in class TrieNode { TrieNode[] children = new TrieNode[26]; boolean isEndOfWord; }.

3. Final Answer:

   class TrieNode { TrieNode[] children = new TrieNode[26]; boolean isEndOfWord; } -> Option D

4. Quick Check:

   Children are TrieNode references [OK]

Hint: Children array holds TrieNode references, not primitives [OK]

Common Mistakes:

• Using int or char arrays instead of TrieNode array
• Using String array for children
• Forgetting to mark end of word

3. Given the following code snippet, what will be the output?

Trie trie = new Trie();
trie.insert("cat");
trie.insert("car");
trie.insert("dog");
System.out.println(trie.startsWith("ca"));
System.out.println(trie.startsWith("do"));
System.out.println(trie.startsWith("bat"));

medium

A. true
true
false

B. true
false
false

C. false
true
false

D. false
false
true

Solution

1. Step 1: Insert words into the Trie

   Words "cat", "car", and "dog" are inserted, so prefixes "ca" and "do" exist in the Trie.

2. Step 2: Check startsWith results

   startsWith("ca") returns true because "cat" and "car" start with "ca".
   startsWith("do") returns true because "dog" starts with "do".
   startsWith("bat") returns false because no word starts with "bat".

3. Final Answer:

   true true false -> Option A

4. Quick Check:

   Prefix "ca" and "do" found, "bat" not found [OK]

Hint: Check inserted words' prefixes carefully [OK]

Common Mistakes:

• Assuming startsWith returns false if word not complete
• Confusing startsWith with search for whole word
• Mixing up true/false outputs

4. The following Java method is intended to check if a prefix exists in a Trie, but it has a bug. What is the bug?

public boolean startsWith(String prefix) {
    TrieNode node = root;
    for (int i = 0; i <= prefix.length(); i++) {
        char c = prefix.charAt(i);
        if (node.children[c - 'a'] == null) return false;
        node = node.children[c - 'a'];
    }
    return true;
}

medium

A. The root node is not initialized before the loop

B. The loop condition should be < instead of <= to avoid IndexOutOfBoundsException

C. The method should return false at the end instead of true

D. The character indexing is wrong; should use c + 'a'

Solution

1. Step 1: Analyze the for-loop condition

   The loop runs from i = 0 to i <= prefix.length(), which means it tries to access prefix.charAt(prefix.length()), causing an IndexOutOfBoundsException.

2. Step 2: Correct the loop condition

   The loop should run while i < prefix.length() to access valid characters only.

3. Final Answer:

   The loop condition should be < instead of <= to avoid IndexOutOfBoundsException -> Option B

4. Quick Check:

   Loop index must be less than length [OK]

Hint: Loop index must be less than string length [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Incorrect character arithmetic
• Returning wrong boolean at the end

5. You want to find all words in a Trie that start with the prefix "app". Which approach correctly retrieves all such words?

hard

A. Use a hash map to store all words and filter those starting with "app"

B. Search each word in the Trie individually to check if it starts with "app"

C. Traverse the Trie to the node representing 'p' in "app", then perform a depth-first search collecting all words below

D. Insert "app" as a word and then search for it

Solution

1. Step 1: Locate the prefix node in the Trie

   Traverse the Trie following letters 'a', 'p', 'p' to reach the node representing the last 'p' in "app".

2. Step 2: Collect all words below this node

   Perform a depth-first search (DFS) from this node to find all complete words that start with "app".

3. Final Answer:

   Traverse the Trie to the node representing 'p' in "app", then perform a depth-first search collecting all words below -> Option C

4. Quick Check:

   Prefix node + DFS = all matching words [OK]

Hint: Find prefix node, then DFS to collect words [OK]

Common Mistakes:

• Checking all words instead of using Trie structure
• Using hash map instead of Trie traversal
• Confusing insertion with search