Why Trie Exists and What Hash Map Cannot Do for Strings in DSA C - Performance Analysis

Time Complexity: Why Trie Exists and What Hash Map Cannot Do for Strings

O(n)

Understanding Time Complexity

We want to understand why tries are used for strings instead of hash maps.

What makes tries faster or better for some string tasks?

Scenario Under Consideration

Analyze the time complexity of inserting and searching strings in a trie.

// Insert a word into a trie
void insert(struct TrieNode* root, const char* word) {
    struct TrieNode* node = root;
    for (int i = 0; word[i] != '\0'; i++) {
        int index = word[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = createNode();
        }
        node = node->children[index];
    }
    node->isEndOfWord = 1;
}
    

This code inserts each character of a word into a trie node by node.

Identify Repeating Operations

Look at the loop that goes through each character of the word.

• Primary operation: Loop over each character in the input string.
• How many times: Exactly once per character, so length of the word.

How Execution Grows With Input

As the word gets longer, the number of steps grows directly with its length.

Input Size (n)	Approx. Operations
10	10 steps (one per character)
100	100 steps
1000	1000 steps

Pattern observation: The work grows linearly with the length of the string.

Final Time Complexity

Time Complexity: O(n)

This means the time to insert or search depends only on the string length, not the number of stored words.

Common Mistake

[X] Wrong: "Hash maps always give O(1) time for string search, so tries are not needed."

[OK] Correct: Hash maps depend on hashing the whole string, which can take O(n) time per operation and can cause collisions. Tries avoid collisions and give predictable O(n) time based on string length, independent of number of stored words.

Interview Connect

Understanding why tries exist helps you explain trade-offs in data structures for strings clearly and confidently.

Self-Check

What if we used a hash map that stores prefixes of strings instead of whole strings? How would that affect time complexity?

Practice

1. Why do we use a Trie data structure instead of a Hash Map for storing strings?

easy

A. Because Trie is faster for all types of data retrieval

B. Because Trie supports efficient prefix search which Hash Map cannot do easily

C. Because Hash Map cannot store strings as keys

D. Because Trie uses less memory than Hash Map for all data types

Solution

1. Step 1: Understand Trie and Hash Map capabilities

   Trie stores strings in a tree form allowing prefix-based queries efficiently. Hash Map stores key-value pairs but does not support prefix search efficiently.

2. Step 2: Compare prefix search ability

   Trie can quickly find all strings starting with a prefix. Hash Map requires checking all keys or extra structures, which is inefficient.

3. Final Answer:

   Because Trie supports efficient prefix search which Hash Map cannot do easily -> Option B

4. Quick Check:

   Prefix search = Trie [OK]

Hint: Trie excels at prefix search, Hash Map does not [OK]

Common Mistakes:

• Thinking Hash Map cannot store strings as keys
• Believing Trie always uses less memory
• Assuming Trie is faster for all queries

2. Which of the following is the correct way to declare a Trie node structure in C?

easy

A. struct TrieNode { char* children; int isEndOfWord; };

B. struct TrieNode { int children; bool isEndOfWord; };

C. struct TrieNode { struct TrieNode* children[26]; bool isEndOfWord; };

D. struct TrieNode { struct TrieNode children; bool isEndOfWord; };

Solution

1. Step 1: Understand Trie node structure

   A Trie node typically has an array of pointers to child nodes (for each alphabet letter) and a boolean to mark end of word.

2. Step 2: Check each option

   struct TrieNode { struct TrieNode* children[26]; bool isEndOfWord; }; correctly declares an array of 26 pointers and a boolean flag. Others have wrong types or missing pointers.

3. Final Answer:

   struct TrieNode { struct TrieNode* children[26]; bool isEndOfWord; }; -> Option C

4. Quick Check:

   Trie node = array of pointers + bool [OK]

Hint: Trie node has pointer array for children and bool flag [OK]

Common Mistakes:

• Using int instead of pointer array for children
• Declaring children as single struct instead of array
• Confusing data types for isEndOfWord

3. What is the output of the following C code snippet that inserts "cat" and "car" into a Trie and checks prefix "ca"?

insert("cat");
insert("car");
bool result = startsWith("ca");
printf("%d", result);

medium

A. 1

B. 0

C. Compilation error

D. Undefined behavior

Solution

1. Step 1: Understand insert and startsWith functions

   Inserting "cat" and "car" adds nodes for 'c', 'a', 't' and 'r'. startsWith("ca") checks if any word starts with "ca".

2. Step 2: Check if prefix "ca" exists

   Both words start with "ca", so startsWith("ca") returns true (1).

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Prefix "ca" found = 1 [OK]

Hint: If words share prefix, startsWith returns 1 [OK]

Common Mistakes:

• Assuming startsWith returns 0 if prefix is partial
• Confusing insert with search function
• Ignoring that both words share prefix

4. Given this buggy Trie insertion code in C, what is the main error?

void insert(struct TrieNode* root, char* word) {
  struct TrieNode* node = root;
  for (int i = 0; word[i] != '\0'; i++) {
    int index = word[i] - 'a';
    if (node->children[index] == NULL) {
      node->children[index] = malloc(sizeof(struct TrieNode));
    }
    node = node->children[index];
  }
  node->isEndOfWord = true;
}

medium

A. isEndOfWord is set before loop

B. Index calculation is incorrect

C. Root node is not passed correctly

D. New nodes are not initialized to NULL

Solution

1. Step 1: Analyze node allocation

   When malloc allocates new TrieNode, its children pointers and isEndOfWord are uninitialized garbage values.

2. Step 2: Identify missing initialization

   New nodes must have children array set to NULL and isEndOfWord set to false to avoid errors during traversal.

3. Final Answer:

   New nodes are not initialized to NULL -> Option D

4. Quick Check:

   Uninitialized nodes cause bugs [OK]

Hint: Always initialize new Trie nodes after malloc [OK]

Common Mistakes:

• Thinking index calculation is wrong
• Setting isEndOfWord too early
• Assuming root node passing is incorrect

5. You want to store a large dictionary of words and quickly find all words starting with a given prefix. Why is Trie a better choice than Hash Map, and what is a key limitation of Hash Map in this scenario?

hard

A. Trie allows prefix search in O(k) time; Hash Map cannot do prefix search efficiently

B. Trie uses less memory; Hash Map cannot store strings as keys

C. Hash Map is slower for exact matches; Trie cannot store full words

D. Hash Map requires sorting keys; Trie automatically sorts keys

Solution

1. Step 1: Understand prefix search complexity

   Trie can find all words with a prefix in time proportional to prefix length (O(k)), independent of dictionary size.

2. Step 2: Identify Hash Map limitation

   Hash Map supports exact key lookup efficiently but cannot efficiently find keys by prefix without scanning all keys.

3. Final Answer:

   Trie allows prefix search in O(k) time; Hash Map cannot do prefix search efficiently -> Option A

4. Quick Check:

   Prefix search = Trie advantage [OK]

Hint: Trie = fast prefix search; Hash Map = exact match only [OK]

Common Mistakes:

• Believing Hash Map cannot store strings as keys
• Thinking Trie uses less memory always
• Confusing sorting with prefix search