Why Trie Exists and What Hash Map Cannot Do for Strings in DSA C - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a character into the Trie node's children array.

DSA C

node->children[[1]] = createNode();

Drag options to blanks, or click blank then click option'

Ac + 'a'

Bc - 'a'

Cc * 'a'

D'a' - c

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of subtraction for index calculation.

Using character directly as index without conversion.

We subtract 'a' from the character to get the index 0-25 for lowercase letters.

2fill in blank

medium

Complete the code to check if a Trie node has a child for a given character.

DSA C

if (node->children[[1]] != NULL) { /* child exists */ }

Drag options to blanks, or click blank then click option'

Ac + 'a'

B'a' - c

Cc - 'a'

Dc * 'a'

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or multiplication instead of subtraction.

Checking wrong index leading to incorrect child detection.

Subtracting 'a' from the character gives the correct index to check in children array.

3fill in blank

hard

Fix the error in the function that searches for a prefix in the Trie.

DSA C

for (int i = 0; i < length; i++) {
    if (node->children[[1]] == NULL) {
        return false;
    }
    node = node->children[[1]];
}
return true;

Drag options to blanks, or click blank then click option'

Aprefix[i] - 'a'

Bprefix[i] + 'a'

C'a' - prefix[i]

Di - 'a'

Attempts:

3 left

💡 Hint

Common Mistakes

Using prefix[i] + 'a' which gives wrong index.

Using loop variable i as index directly.

We must subtract 'a' from the character at prefix[i] to get the correct index.

4fill in blank

hard

Fill both blanks to create a Trie node and initialize its children to NULL.

DSA C

TrieNode* node = (TrieNode*)malloc(sizeof([1]));
for (int i = 0; i < [2]; i++) {
    node->children[i] = NULL;
}

Drag options to blanks, or click blank then click option'

ATrieNode

BTrie

C26

D256

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong struct name in malloc.

Initializing wrong number of children.

We allocate memory for TrieNode and initialize 26 children for lowercase letters.

5fill in blank

hard

Fill all three blanks to implement a function that inserts a word into the Trie.

DSA C

void insert(TrieNode* root, const char* word) {
    TrieNode* node = root;
    for (int i = 0; word[i] != '\0'; i++) {
        int index = [1];
        if (node->children[index] == NULL) {
            node->children[index] = [2];
        }
        node = node->children[index];
    }
    node->isEndOfWord = [3];
}

Drag options to blanks, or click blank then click option'

Aword[i] - 'a'

BcreateNode()

Ctrue

Dword[i] + 'a'

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition instead of subtraction for index.

Not creating new node when child is NULL.

Not marking end of word correctly.

We calculate index by subtracting 'a', create a new node if needed, and mark end of word as true.

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