Trie Search Operation in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Trie Search for Existing Word

What is the output of the following C# code that inserts words into a Trie and searches for the word "cat"?

DSA C#

using System;
using System.Collections.Generic;

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

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

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

    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 node.IsEndOfWord;
    }
}

class Program {
    static void Main() {
        Trie trie = new Trie();
        trie.Insert("cat");
        trie.Insert("car");
        trie.Insert("dog");
        Console.WriteLine(trie.Search("cat"));
    }
}

A True

B Runtime Exception

C Compilation Error

D False

💡 Hint

Check if the word "cat" was inserted before searching.

The word "cat" was inserted into the Trie, so searching for it returns true.

❓ Predict Output

intermediate

Output of Trie Search for Non-Existing Word

What is the output of the following C# code that inserts words into a Trie and searches for the word "bat"?

DSA C#

using System;
using System.Collections.Generic;

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

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

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

    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 node.IsEndOfWord;
    }
}

class Program {
    static void Main() {
        Trie trie = new Trie();
        trie.Insert("cat");
        trie.Insert("car");
        trie.Insert("dog");
        Console.WriteLine(trie.Search("bat"));
    }
}

A False

B True

C Compilation Error

D Runtime Exception

💡 Hint

Check if the word "bat" was inserted before searching.

The word "bat" was not inserted into the Trie, so searching for it returns false.

🧠 Conceptual

advanced

Understanding Trie Search Behavior

In a Trie, what does it mean if the search for a word returns true?

A The search encountered a null reference and failed.

B The word does not exist in the Trie at all.

C The word exists in the Trie and is marked as a complete word.

D The word is a prefix of some word in the Trie but not necessarily a complete word.

💡 Hint

Think about the meaning of the end-of-word marker in Trie nodes.

A search returns true only if the path for the word exists and the last node is marked as the end of a word.

❓ Predict Output

advanced

Output of Trie Search for Prefix Only Word

What is the output of the following C# code that inserts "car" and searches for "ca"?

DSA C#

using System;
using System.Collections.Generic;

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

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

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

    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 node.IsEndOfWord;
    }
}

class Program {
    static void Main() {
        Trie trie = new Trie();
        trie.Insert("car");
        Console.WriteLine(trie.Search("ca"));
    }
}

A True

B False

C Compilation Error

D Runtime Exception

💡 Hint

Check if "ca" is marked as a complete word in the Trie.

The search returns false because "ca" is only a prefix and not marked as a complete word.

🧠 Conceptual

expert

Why Trie Search is Efficient for Prefix Queries

Why is searching for a prefix in a Trie generally faster than searching in a list of strings?

A Because Trie uses hashing internally to find words instantly.

B Because Trie stores all words in a single string, making search O(1).

C Because Trie sorts all words alphabetically before searching.

D Because Trie nodes share common prefixes, reducing repeated comparisons.

💡 Hint

Think about how Trie nodes represent shared parts of words.

Trie nodes represent shared prefixes, so searching a prefix only traverses nodes once, avoiding repeated checks on each 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