Trie Search Operation in DSA C#

Mental Model

A trie stores words by linking letters in a tree. Searching means following letters step-by-step to see if the word exists.

Analogy: Imagine a phone book organized by first letter, then second letter, and so on. To find a name, you open the first letter section, then the next, until you find the full name or not.

root
 ↓
 [c] -> [a] -> [t] (end)
        ↓
       [r] -> [e] -> [t] (end)

↑ start at root

Dry Run Walkthrough

Input: Trie contains words: "cat", "car", "caret"; search for "car"

Goal: Find if the word "car" exists in the trie

Step 1: Start at root node, look for child 'c'

root -> [c] -> ...

Why: We need to find the first letter of the word

Step 2: Move to node 'c', look for child 'a'

root -> c -> [a] -> ...

Why: Next letter in the word is 'a', so follow that link

Step 3: Move to node 'a', look for child 'r'

root -> c -> a -> [r] -> ...

Why: Next letter is 'r', continue following

Step 4: Move to node 'r', check if this node marks end of word

root -> c -> a -> r (end=true) -> ...

Why: If this node marks end, word exists

Result:

root -> c -> a -> r (end=true)
Answer: Word "car" found

Annotated Code

DSA C#

using System;
using System.Collections.Generic;

public class TrieNode
{
    public Dictionary<char, TrieNode> Children = new Dictionary<char, TrieNode>();
    public bool IsEndOfWord = false;
}

public class Trie
{
    private TrieNode root = new TrieNode();

    public void Insert(string word)
    {
        TrieNode current = root;
        foreach (char ch in word)
        {
            if (!current.Children.ContainsKey(ch))
            {
                current.Children[ch] = new TrieNode();
            }
            current = current.Children[ch];
        }
        current.IsEndOfWord = true;
    }

    public bool Search(string word)
    {
        TrieNode current = root;
        foreach (char ch in word)
        {
            if (!current.Children.ContainsKey(ch))
            {
                return false; // letter missing, word not found
            }
            current = current.Children[ch];
        }
        return current.IsEndOfWord; // true if word ends here
    }
}

public class Program
{
    public static void Main()
    {
        Trie trie = new Trie();
        trie.Insert("cat");
        trie.Insert("car");
        trie.Insert("caret");

        Console.WriteLine(trie.Search("car") ? "Word 'car' found" : "Word 'car' not found");
    }
}

foreach (char ch in word)

iterate each letter to follow trie path

if (!current.Children.ContainsKey(ch))

check if current node has child for letter

return false; // letter missing, word not found

stop search early if letter path missing

current = current.Children[ch];

move to next node for letter

return current.IsEndOfWord; // true if word ends here

confirm word ends exactly here

Output

Word 'car' found

Complexity Analysis

Time: O(m) because we check each of the m letters in the search word once

Space: O(1) for search since no extra space grows with input during search

vs Alternative: Compared to searching in a list of words (O(n*m)), trie search is faster because it uses letter-by-letter links

Edge Cases

Search for empty string

Returns false because empty word is not stored

DSA C#

return current.IsEndOfWord; // true if word ends here

Search for word not inserted

Returns false when a letter is missing in trie

DSA C#

if (!current.Children.ContainsKey(ch))
                {
                    return false; // letter missing, word not found
                }

Search for prefix but not full word

Returns false if path exists but node is not end of word

DSA C#

return current.IsEndOfWord; // true if word ends here

When to Use This Pattern

When you need to quickly check if a word or prefix exists among many words, use the trie search pattern because it follows letters stepwise for fast lookup.

Common Mistakes

Mistake: Returning true just because the path exists without checking if node marks end of word
Fix: Always check the IsEndOfWord flag at the last node to confirm full word presence

Summary

Searches for a word by following letter nodes step-by-step in the trie.

Use when you want fast word lookups among many stored words.

The key is to confirm the path exists and the last node marks the end of a word.

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. Inserts a new word into the Trie

C. Deletes a word from 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. Search only checks existence.

3. Final Answer:

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

4. Quick Check:

   Search = Check word presence [OK]

Hint: Search checks presence, 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 C# method signature for a Trie search operation that returns a boolean?

easy

A. public void Search(string word)

B. public bool Search(string word)

C. public int Search(string word)

D. public string Search(string word)

Solution

1. Step 1: Identify return type for search

   Search should return true or false indicating if the word exists, so return type must be bool.

2. Step 2: Check method signature correctness

   Method takes a string parameter for the word and returns bool, matching "public bool Search(string word)".

3. Final Answer:

   public bool Search(string word) -> Option B

4. Quick Check:

   Search returns bool for word presence [OK]

Hint: Search returns true/false, so return type is bool [OK]

Common Mistakes:

• Using void return type for search
• Returning int or string instead of bool
• Incorrect method parameter types

3. Given the following Trie search code snippet, what will be the output when searching for the word "cat" after inserting "car" and "cat"?

Trie trie = new Trie();
trie.Insert("car");
trie.Insert("cat");
Console.WriteLine(trie.Search("cat"));
Console.WriteLine(trie.Search("cap"));

medium

A. False
True

B. True
True

C. True
False

D. False
False

Solution

1. Step 1: Analyze inserted words

   Words "car" and "cat" are inserted, so both exist in the Trie.

2. Step 2: Check search results for "cat" and "cap"

   "cat" exists, so search returns true; "cap" was not inserted, so search returns false.

3. Final Answer:

   True False -> Option C

4. Quick Check:

   Search("cat")=True, Search("cap")=False [OK]

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

Common Mistakes:

• Assuming "cap" exists after inserting "car" and "cat"
• Mixing output order
• Confusing true/false outputs

4. Identify the bug in this Trie search method that causes it to always return false:

public bool Search(string word) {
    TrieNode node = root;
    foreach (char c in word) {
        if (!node.Children.ContainsKey(c))
            return false;
        node = node.Children[c];
    }
    return false;
}

medium

A. The method should return true immediately after first character check

B. It should return false if node.Children contains the character

C. The foreach loop should iterate over node.Children keys

D. It should return true after checking all characters if node marks end of word

Solution

1. Step 1: Understand the search logic

   The method checks each character in the word exists in the Trie nodes.

2. Step 2: Identify the missing return condition

   After the loop, it always returns false instead of checking if the current node marks the end of a valid word.

3. Final Answer:

   It should return true after checking all characters if node marks end of word -> Option D

4. Quick Check:

   Return true if end of word reached [OK]

Hint: Return true only if end of word node reached [OK]

Common Mistakes:

• Returning false unconditionally after loop
• Not checking end of word flag
• Returning true too early

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

hard

A. Return true as soon as all prefix characters are found, without checking end of word

B. Return true only if the prefix is also a complete word in the Trie

C. Return false if any character in prefix is found

D. Return true only if prefix length equals word length

Solution

1. Step 1: Understand prefix search goal

   Prefix search should confirm if the Trie contains any word starting with the given prefix.

2. Step 2: Adjust search logic for prefix

   Return true immediately after all prefix characters are found, no need to check if prefix is a complete word.

3. Final Answer:

   Return true as soon as all prefix characters are found, without checking end of word -> Option A

4. Quick Check:

   Prefix found = true without full word check [OK]

Hint: Prefix search returns true once prefix path exists [OK]

Common Mistakes:

• Checking end of word for prefix search
• Returning false if prefix is not a full word
• Confusing prefix search with full word search