Trie Search Operation in DSA Typescript - Execution Trace

Concept Flow - Trie Search Operation

Start at root node

↓

For each character in word

↓

Check if character exists in current node's children

↓

Move to child node

↓

After last character, check isEndOfWord

↓

Word found

↓

End

The search starts at the root and checks each character in the word. If a character is missing, search stops. If all characters are found, it checks if the last node marks the end of a word.

Execution Sample

DSA Typescript

function search(word: string): boolean {
  let node = root;
  for (const char of word) {
    if (!node.children.has(char)) return false;
    node = node.children.get(char)!;
  }
  return node.isEndOfWord;
}

This code searches for a word in the trie by traversing nodes for each character and returns true if the word exists.

Execution Table

Step	Operation	Current Character	Node Children Keys	Pointer Change	Visual State
1	Start at root	-	a, b, c	node = root	root → {a, b, c}
2	Check 'c'	c	a, b, c	node = node.children.get('c')	root → c node → {a, t}
3	Check 'a'	a	a, t	node = node.children.get('a')	c node → a node → {t}
4	Check 't'	t	t	node = node.children.get('t')	a node → t node → {}
5	Check isEndOfWord	-	-	-	t node isEndOfWord = true
6	Return result	-	-	-	Word found: true

💡 Search ends after checking all characters and confirming isEndOfWord is true

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
node	root	c node	a node	t node	t node

Key Moments - 3 Insights

Why do we check isEndOfWord after traversing all characters?

Because a node can exist for a prefix but not mark a complete word. Checking isEndOfWord confirms the word ends here (see Step 5 in execution_table).

What happens if a character is missing in children?

The search stops immediately and returns false, as shown in Step 2 where if 'c' was missing, we would return false.

Why do we update 'node' pointer at each character?

To move deeper into the trie along the path of the word. Each update points to the next node representing the next character (see Pointer Change column).

Visual Quiz - 3 Questions

Look at the execution_table, what is the 'node' variable after Step 3?

A a node

B c node

C root node

D t node

💡 Hint

Check the 'Pointer Change' and 'Variable Tracker' after Step 3

At which step does the search confirm the word exists?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look at the 'Operation' and 'Visual State' columns for isEndOfWord check

If the character 'a' was missing in Step 3, what would happen?

A Search continues to next character

B Return true immediately

C Return false immediately

D Skip character and continue

💡 Hint

Refer to the 'Operation' and 'Pointer Change' logic in Step 2 for missing character

Concept Snapshot

Trie Search Operation:
- Start at root node
- For each character, move to child node if exists
- If missing, return false
- After last char, check isEndOfWord
- Return true if word ends here, else false

Full Transcript

The Trie Search Operation starts at the root node. For each character in the word, it checks if the character exists among the current node's children. If it does, the pointer moves to that child node. If any character is missing, the search stops and returns false. After all characters are found, the search checks if the current node marks the end of a word (isEndOfWord). If yes, the word exists in the trie and returns true; otherwise, it returns false.

Practice

1. What does the search operation in a Trie data structure do?

easy

A. Checks if a given word exists in the Trie

B. Deletes a word from the Trie

C. Inserts a new word into the Trie

D. Counts the total words stored in the Trie

Solution

1. Step 1: Understand the purpose of search in Trie

   The search operation is designed to check if a specific word is present in the Trie data structure.

2. Step 2: Differentiate from other operations

   Insertion adds words, deletion removes words, and counting totals words, but search only checks existence.

3. Final Answer:

   Checks if a given word exists in the Trie -> Option A

4. Quick Check:

   Search = Check existence [OK]

Hint: Search checks presence of word, not insertion or deletion [OK]

Common Mistakes:

• Confusing search with insert operation
• Thinking search deletes words
• Assuming search counts words

2. Which of the following is the correct TypeScript method signature for a Trie search function that returns a boolean?

easy

A. search(word: boolean): boolean

B. search(word: number): string

C. search(word: string): void

D. search(word: string): boolean

Solution

1. Step 1: Identify input and output types for search

   The search method takes a word as a string and returns true or false, so input is string and output is boolean.

2. Step 2: Match method signature with correct types

   Only search(word: string): boolean matches the expected input and output types.

3. Final Answer:

   search(word: string): boolean -> Option D

4. Quick Check:

   Input string, output boolean [OK]

Hint: Search takes string, returns true/false [OK]

Common Mistakes:

• Using wrong input type like number or boolean
• Returning void instead of boolean
• Confusing return type with string

3. Given the following TypeScript Trie search code, what will be the output?

const trie = new Trie();
trie.insert('cat');
trie.insert('car');
trie.insert('dog');
console.log(trie.search('car'));
console.log(trie.search('cap'));

medium

A. true\ntrue

B. true\nfalse

C. false\ntrue

D. false\nfalse

Solution

1. Step 1: Check inserted words in Trie

   The words 'cat', 'car', and 'dog' are inserted into the Trie.

2. Step 2: Search for 'car' and 'cap'

   'car' exists in the Trie, so search returns true. 'cap' was not inserted, so search returns false.

3. Final Answer:

   true\nfalse -> Option B

4. Quick Check:

   Inserted words found, missing words not found [OK]

Hint: Inserted words return true, others false [OK]

Common Mistakes:

• Assuming 'cap' is found because it starts like 'car'
• Mixing true/false order in output
• Forgetting to insert words before search

4. Identify the bug in this TypeScript Trie search method:

search(word: string): boolean {
  let node = this.root;
  for (let i = 0; i <= word.length; i++) {
    const char = word[i];
    if (!node.children.has(char)) return false;
    node = node.children.get(char)!;
  }
  return node.isEndOfWord;
}

medium

A. Loop condition should be i < word.length, not <=

B. Missing check for empty string input

C. Should return true before loop ends

D. Incorrect use of non-null assertion operator (!)

Solution

1. Step 1: Analyze loop boundary in search method

   The loop runs from i = 0 to i <= word.length, which means it accesses word[word.length], an undefined index.

2. Step 2: Correct loop condition to avoid out-of-bounds

   The loop should run while i < word.length to access valid characters only.

3. Final Answer:

   Loop condition should be i < word.length, not <= -> Option A

4. Quick Check:

   Loop boundary off by one [OK]

Hint: Loop over characters with i < length, not <= length [OK]

Common Mistakes:

• Using <= causes undefined access
• Ignoring empty string edge case
• Misusing non-null assertion without checks

5. You want to modify a Trie search method to support prefix search (check if any word starts with given prefix). Which change is correct?

hard

A. Return true only if prefix is a complete word (isEndOfWord true)

B. Return false if prefix length is less than 3 characters

C. Return true as soon as all prefix characters are found, without checking isEndOfWord

D. Return true only if prefix matches exactly one word

Solution

1. Step 1: Understand prefix search goal

   Prefix search should confirm if any word starts with the given prefix, not necessarily a complete word.

2. Step 2: Adjust search logic for prefix

   Return true once all prefix characters are found in sequence, without requiring isEndOfWord to be true.

3. Final Answer:

   Return true as soon as all prefix characters are found, without checking isEndOfWord -> Option C

4. Quick Check:

   Prefix found means true, no full word check needed [OK]

Hint: Prefix search stops after matching prefix, ignores full word flag [OK]

Common Mistakes:

• Checking isEndOfWord for prefix search
• Rejecting short prefixes arbitrarily
• Requiring prefix to match exactly one word