Prefix Search Using Trie in DSA C++ - Execution Trace

Concept Flow - Prefix Search Using Trie

Start at root node

↓

For each character in prefix

↓

Check if character child exists?

No→Prefix not found

Yes↓

Move to child node

↓

Repeat for next character

↓

All prefix chars found

↓

Collect all words from current node

↓

Return list of words with prefix

Start from the root and follow each prefix character down the trie. If all prefix characters exist, collect all words below that node.

Execution Sample

DSA C++

insert("cat");
insert("car");
insert("dog");
searchPrefix("ca");

Insert words 'cat', 'car', 'dog' into trie, then search for words starting with prefix 'ca'.

Execution Table

Step	Operation	Nodes in Trie	Pointer Changes	Visual State
1	Insert 'cat' char 'c'	root	root -> c node created	root -> c -> null
2	Insert 'cat' char 'a'	root -> c	c -> a node created	root -> c -> a -> null
3	Insert 'cat' char 't'	root -> c -> a	a -> t node created (end of word)	root -> c -> a -> t*
4	Insert 'car' char 'c'	root -> c -> a -> t*	c node exists, no change	root -> c -> a -> t*
5	Insert 'car' char 'a'	root -> c -> a -> t*	a node exists, no change	root -> c -> a -> t*
6	Insert 'car' char 'r'	root -> c -> a -> t*	a -> r node created (end of word)	root -> c -> a -> t* -> r*
7	Insert 'dog' char 'd'	root -> c -> a -> t* -> r*	root -> d node created	root -> c -> a -> t* -> r* root -> d -> null
8	Insert 'dog' char 'o'	root -> c -> a -> t* -> r* root -> d	d -> o node created	root -> c -> a -> t* -> r* root -> d -> o -> null
9	Insert 'dog' char 'g'	root -> c -> a -> t* -> r* root -> d -> o	o -> g node created (end of word)	root -> c -> a -> t* -> r* root -> d -> o -> g*
10	Search prefix 'ca' char 'c'	root -> c -> a -> t* -> r* root -> d -> o -> g*	Move to c node	At node c
11	Search prefix 'ca' char 'a'	At node c	Move to a node	At node a
12	Prefix 'ca' found, collect words	At node a	Traverse children t* and r*	Words found: 'cat', 'car'

💡 Prefix 'ca' fully matched, words collected from node 'a'.

Variable Tracker

Variable	Start	After Step 3	After Step 6	After Step 9	After Step 12
Trie Nodes	root	root -> c -> a -> t*	root -> c -> a -> t* -> r*	root -> c -> a -> t* -> r* root -> d -> o -> g*	No change, at node a for prefix 'ca'
Current Node	root	root	root	root	node a
Words Collected	[]	[]	[]	[]	["cat", "car"]

Key Moments - 3 Insights

Why do we create new nodes only when the character child does not exist?

Because if the child node for a character already exists (see steps 4 and 5), we reuse it to avoid duplicates and keep the trie compact.

How do we know when a word ends in the trie?

We mark the last character node of a word with a special flag (shown as * in Visual State), as seen in steps 3, 6, and 9.

What happens if the prefix is not found during search?

The search stops immediately when a character child does not exist (not shown here), indicating no words with that prefix.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, which new node is created?

A Node 'd' as child of root

B Node 't' as child of 'a'

C Node 'r' as child of 'a'

D Node 'o' as child of 'd'

💡 Hint

Check the 'Pointer Changes' and 'Visual State' columns at step 6.

At which step does the trie first contain the word 'dog'?

A Step 9

B Step 8

C Step 7

D Step 10

💡 Hint

Look for the step where the last character node 'g' is created and marked as end of word.

According to variable_tracker, what is the current node after step 12?

A root

B node a

C node c

D node t

💡 Hint

Check the 'Current Node' row in variable_tracker after step 12.

Concept Snapshot

Trie stores words as paths from root to nodes.
Insert: create nodes for chars if missing.
Mark end of word nodes.
Prefix search: follow prefix chars.
If prefix found, collect all words below.
Efficient for prefix-based queries.

Full Transcript

This visual trace shows how a trie is built by inserting words 'cat', 'car', and 'dog'. Each character is a node. If a node for a character exists, it is reused. The end of a word is marked with a special flag. Searching for prefix 'ca' involves moving from root to 'c' node, then to 'a' node. Once prefix is matched, all words below are collected. The execution table tracks each insertion and search step, showing node creation and traversal. Variable tracker shows trie structure and current node changes. Key moments clarify why nodes are created only if missing, how word ends are marked, and what happens if prefix is missing. The quiz tests understanding of node creation, word insertion, and search position. The snapshot summarizes trie usage for prefix search.