Word Search in Trie in DSA Python - Time & Space Complexity

Time Complexity: Word Search in Trie

O(n)

Understanding Time Complexity

We want to know how long it takes to find a word in a Trie as the word length changes.

How does the search time grow when the word gets longer?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def search(self, word: str) -> bool:
        node = self.root
        for char in word:
            if char not in node.children:
                return False
            node = node.children[char]
        return node.is_end
    

This code searches for a word in a Trie by checking each character step-by-step.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each character of the word.
• How many times: Exactly once per character in the word (word length).

How Execution Grows With Input

As the word gets longer, the search checks more characters one by one.

Input Size (n)	Approx. Operations
10	About 10 character checks
100	About 100 character checks
1000	About 1000 character checks

Pattern observation: The number of operations grows directly with the word length.

Final Time Complexity

Time Complexity: O(n)

This means the search time grows linearly with the length of the word you are looking for.

Common Mistake

[X] Wrong: "Searching a word in a Trie takes constant time because it's a tree."

[OK] Correct: The search depends on the word length, so longer words take more steps, not always constant time.

Interview Connect

Understanding this helps you explain how Tries speed up searches compared to checking every word, and shows you can analyze step-by-step costs clearly.

Self-Check

"What if the Trie stored words with a fixed maximum length? How would that affect the time complexity?"

Practice

1. What is the main purpose of using a Trie data structure in word search problems?

easy

A. To store words in a way that allows fast prefix-based search

B. To sort words alphabetically

C. To store words in a linked list

D. To compress words into a single string

Solution

1. Step 1: Understand the Trie structure

   A Trie stores characters of words in a tree-like structure where each node represents a character.

2. Step 2: Identify the main use in word search

   This structure allows quick lookup of words by their prefixes, making prefix-based search very efficient.

3. Final Answer:

   To store words in a way that allows fast prefix-based search -> Option A

4. Quick Check:

   Trie = fast prefix search [OK]

Hint: Trie is all about prefix search speed [OK]

Common Mistakes:

• Confusing Trie with sorting structures
• Thinking Trie stores words as linked lists
• Assuming Trie compresses words into strings

2. Which of the following is the correct way to check if a character ch exists as a child node in a Trie node's children dictionary named children?

easy

A. if ch in children.keys():

B. if children.has_key(ch):

C. if ch in children:

D. if children.contains(ch):

Solution

1. Step 1: Recall Python dictionary membership check

   In Python, to check if a key exists in a dictionary, use key in dict.

2. Step 2: Identify the correct syntax

   if ch in children: is the correct and most Pythonic way to check key existence.

3. Final Answer:

   if ch in children: -> Option C

4. Quick Check:

   Python dict key check = 'in' keyword [OK]

Hint: Use 'in' keyword to check dict keys in Python [OK]

Common Mistakes:

• Using deprecated has_key() method
• Checking keys() explicitly which is slower
• Using non-existent contains() method

3. Consider the following Python code snippet for searching a word in a Trie:

def search_word(root, word):
    node = root
    for ch in word:
        if ch not in node.children:
            return False
        node = node.children[ch]
    return node.is_end_of_word

# Trie nodes and root are properly initialized
result = search_word(root, 'cat')

If the Trie contains the words ['car', 'cat', 'cap'], what will be the value of result?

medium

A. None

B. False

C. KeyError

D. True

Solution

1. Step 1: Trace the search for 'cat'

   The function checks each character 'c', 'a', 't' in the Trie nodes. Since 'cat' is inserted, all characters exist and the last node marks end of word.

2. Step 2: Return the end of word flag

   Because 'cat' is a complete word in the Trie, node.is_end_of_word is True, so the function returns True.

3. Final Answer:

   True -> Option D

4. Quick Check:

   Word 'cat' found = True [OK]

Hint: If all chars found and end flag True, return True [OK]

Common Mistakes:

• Returning True without checking end_of_word flag
• Assuming partial prefix means word exists
• Confusing missing character with KeyError

4. The following code tries to search a word in a Trie but raises an error. Identify the bug:

def search_word(root, word):
    node = root
    for ch in word:
        if ch not in node:
            return False
        node = node[ch]
    return node.is_end_of_word

medium

A. Should use 'node.children[ch]' instead of 'node[ch]'

B. Both B and C are correct

C. Should check 'ch not in node.children' instead of 'ch not in node'

D. No bug, code is correct

Solution

1. Step 1: Analyze membership check

   The code checks if ch not in node, but node is an object, not a dictionary. It should check node.children.

2. Step 2: Analyze node traversal

   Similarly, node = node[ch] is incorrect; it should be node = node.children[ch] to access the child node.

3. Final Answer:

   Both B and C are correct -> Option B

4. Quick Check:

   Access children dict properly = Both fixes needed [OK]

Hint: Always access children dict, not node directly [OK]

Common Mistakes:

• Checking keys on node object instead of children dict
• Assigning node = node[ch] instead of node.children[ch]
• Ignoring attribute errors from wrong access

5. You want to find if any word in a Trie starts with a given prefix prefix. Which modification to the standard word search function below will correctly check for prefix existence?

def starts_with(root, prefix):
    node = root
    for ch in prefix:
        if ch not in node.children:
            return False
        node = node.children[ch]
    # What to return here?

hard

A. Return True immediately after loop ends

B. Return node.is_end_of_word

C. Return False if node has no children

D. Return True only if prefix length is 1

Solution

1. Step 1: Understand prefix search logic

   To check if any word starts with the prefix, we only need to confirm all prefix characters exist in the Trie.

2. Step 2: Decide return value after loop

   If all characters are found, return True immediately. We do not need to check if the node marks end of a word.

3. Final Answer:

   Return True immediately after loop ends -> Option A

4. Quick Check:

   Prefix found = True [OK]

Hint: If prefix chars found, return True regardless of word end [OK]

Common Mistakes:

• Returning is_end_of_word which fails for prefixes not full words
• Checking children existence unnecessarily
• Restricting prefix length to 1