Trie Search Operation in DSA Go - Execution Trace

Concept Flow - Trie Search Operation

Start at root node

↓

Check next character in word

↓

Does child node for char exist?

No→Word NOT found, stop

Yes↓

Move pointer to child node

↓

More characters left?

Yes→Repeat check for next char

No↓

Is current node marked as end of word?

Yes→Word FOUND

No↓

Word NOT found

The search starts at the root and checks each character of the word by moving through child nodes. If any character node is missing, search stops. If all characters are found and the last node marks end of word, the word exists.

Execution Sample

DSA Go

func Search(root *TrieNode, word string) bool {
    current := root
    for _, ch := range word {
        if current.children[ch-'a'] == nil {
            return false
        }
        current = current.children[ch-'a']
    }
    return current.isEnd
}

Searches for a word in the trie by traversing nodes for each character.

Execution Table

Step	Operation	Current Character	Node Exists?	Pointer Change	Trie State Visual
1	Start at root	-	N/A	current = root	root →
2	Check character 'c'	c	Yes	current = child node for 'c'	root → c
3	Check character 'a'	a	Yes	current = child node for 'a'	root → c → a
4	Check character 't'	t	Yes	current = child node for 't'	root → c → a → t
5	No more characters	-	-	-	At node 't' (isEnd = true)
6	Check isEnd flag	-	N/A	-	Word FOUND
7	End search	-	-	-	Search complete

💡 Search stops because all characters found and last node marks end of word.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
current	root	node for 'c'	node for 'a'	node for 't'	node for 't'	node for 't'
current Character	-	'c'	'a'	't'	-	-

Key Moments - 3 Insights

Why do we check if the child node for a character exists before moving?

Because if the child node does not exist (see Step 2-4 in execution_table), it means the word cannot be formed from the trie, so we stop searching immediately.

Why do we check the isEnd flag after traversing all characters?

Because even if all characters are found (Step 5), the word is only valid if the last node marks the end of a word (Step 6). Otherwise, the searched string is just a prefix, not a complete word.

What happens if the word is empty?

The search starts and ends at the root node. If root.isEnd is true, empty word exists; otherwise, it does not. This is a special edge case.

Visual Quiz - 3 Questions

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

A Node for 'c'

B Node for 't'

C Node for 'a'

D Root node

💡 Hint

Check the 'Pointer Change' and 'Current Character' columns at Step 3 in execution_table.

At which step does the search confirm the word is found?

A Step 6

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the step where 'Word FOUND' appears in the 'Trie State Visual' column.

If the child node for 'a' was missing at Step 3, what would happen?

A Search continues to next character

B Search stops and returns false

C Search marks word as found

D Search restarts from root

💡 Hint

Refer to the 'Node Exists?' column and the concept_flow where missing child node leads to stopping search.

Concept Snapshot

Trie Search Operation:
- Start at root node
- For each character in word:
  - Check if child node exists
  - Move to child node if yes
  - Stop and return false if no
- After last char, check isEnd flag
- Return true if isEnd is true, else false

Full Transcript

The trie search operation begins at the root node. For each character in the word, it checks if a child node exists for that character. If it does, the search pointer moves to that child node. If not, the search stops and returns false, meaning the word is not in the trie. After all characters are checked, the search verifies if the current node marks the end of a word. If yes, the word is found; otherwise, it is not. This process ensures efficient prefix-based search in the trie data structure.