Trie Insert Operation in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting words into a Trie

What is the printed output of the Trie structure after inserting the words "cat", "car", and "dog" in this C++ code?

DSA C++

struct TrieNode {
    TrieNode* children[26] = {nullptr};
    bool isEnd = false;
};

class Trie {
public:
    TrieNode* root;
    Trie() { root = new TrieNode(); }

    void insert(const std::string& word) {
        TrieNode* node = root;
        for (char c : word) {
            int index = c - 'a';
            if (!node->children[index])
                node->children[index] = new TrieNode();
            node = node->children[index];
        }
        node->isEnd = true;
    }

    void printTrie(TrieNode* node, std::string prefix) {
        if (node->isEnd) {
            std::cout << prefix << "\n";
        }
        for (int i = 0; i < 26; i++) {
            if (node->children[i]) {
                printTrie(node->children[i], prefix + char('a' + i));
            }
        }
    }
};

int main() {
    Trie trie;
    trie.insert("cat");
    trie.insert("car");
    trie.insert("dog");
    trie.printTrie(trie.root, "");
    return 0;
}

A "car\ndog\ncat\n"

B "cat\ncar\ndog\n"

C "dog\ncar\ncat\n"

D "car\ncat\ndog\n"

💡 Hint

Think about how the printTrie function recursively prints words in alphabetical order.

The printTrie function prints words in lexicographical order because it recursively visits children from 'a' to 'z'. The words inserted are "cat", "car", and "dog". Among "car" and "cat", "car" comes first alphabetically, then "cat", then "dog".

❓ Predict Output

intermediate

Number of nodes after inserting words in Trie

After inserting the words "apple" and "app" into an empty Trie, how many Trie nodes are created in total?

DSA C++

struct TrieNode {
    TrieNode* children[26] = {nullptr};
    bool isEnd = false;
};

class Trie {
public:
    TrieNode* root;
    int nodeCount;
    Trie() {
        root = new TrieNode();
        nodeCount = 1; // root node
    }

    void insert(const std::string& word) {
        TrieNode* node = root;
        for (char c : word) {
            int index = c - 'a';
            if (!node->children[index]) {
                node->children[index] = new TrieNode();
                nodeCount++;
            }
            node = node->children[index];
        }
        node->isEnd = true;
    }
};

int main() {
    Trie trie;
    trie.insert("apple");
    trie.insert("app");
    std::cout << trie.nodeCount << std::endl;
    return 0;
}

A 6

B 7

C 5

D 8

💡 Hint

Count nodes created for each unique character. Shared prefixes reuse nodes.

Inserting "apple" creates nodes for 'a', 'p', 'p', 'l', 'e' plus the root node = 6 nodes. Inserting "app" reuses 'a', 'p', 'p' nodes, so no new nodes are added. Total nodes = 6.

🔧 Debug

advanced

Identify the bug in Trie insert method

What error will occur when running this Trie insert method code snippet?

DSA C++

void insert(std::string word) {
    TrieNode* node = root;
    for (int i = 0; i <= word.length(); i++) {
        int index = word[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = new TrieNode();
        }
        node = node->children[index];
    }
    node->isEnd = true;
}

A Logical error: isEnd flag never set

B Runtime error: accessing out-of-bounds index in string

C Compilation error: missing return type

D No error, code runs correctly

💡 Hint

Check the loop boundary condition carefully.

The loop runs from i = 0 to i <= word.length(), which means it accesses word[word.length()] on last iteration. This is out-of-bounds and causes runtime error.

🧠 Conceptual

advanced

Trie insert operation complexity

What is the time complexity of inserting a word of length n into a Trie?

A O(n), where n is the length of the word

B O(log n), where n is the length of the word

C O(1), constant time

D O(n^2), quadratic time

💡 Hint

Consider how many characters you process during insertion.

Insertion processes each character once, so time complexity is linear in the word length, O(n).

🚀 Application

expert

Result of inserting overlapping words in Trie

Given an empty Trie, after inserting the words "bat", "bath", and "batman", which of the following words will be recognized as complete words in the Trie?

A ["bath", "batman"]

B ["bat", "bath"]

C ["bat", "bath", "batman"]

D ["batman"]

💡 Hint

Check which nodes have the isEnd flag set after all insertions.

Each inserted word sets isEnd at its last character node. All three words are inserted fully, so all three are recognized as complete words.

Practice

1. What is the main purpose of the insert operation in a Trie data structure?

easy

A. To count the number of words stored in the Trie

B. To delete a word from the Trie

C. To add a new word character by character into the Trie

D. To search for a word in the Trie

Solution

1. Step 1: Understand the insert operation

   The insert operation adds each character of a word into the Trie, creating nodes if they don't exist.

2. Step 2: Differentiate from other operations

   Deleting removes words, searching checks presence, counting totals words. Insert specifically adds words.

3. Final Answer:

   To add a new word character by character into the Trie -> Option C

4. Quick Check:

   Insert = Add word [OK]

Hint: Insert means adding word step-by-step [OK]

Common Mistakes:

• Confusing insert with search or delete
• Thinking insert counts words
• Assuming insert replaces existing words

2. Which of the following is the correct way to declare a Trie node class in C++ for insertion?

easy

A. class TrieNode { public: vector<char> children; bool isEnd; TrieNode() { isEnd = false; } };

B. class TrieNode { public: int children[26]; bool isEnd; TrieNode() { for(int i=0; i<26; i++) children[i] = 0; isEnd = false; } };

C. class TrieNode { public: TrieNode children[26]; bool isEnd; TrieNode() { isEnd = false; } };

D. class TrieNode { public: TrieNode* children[26]; bool isEnd; TrieNode() { for(int i=0; i<26; i++) children[i] = nullptr; isEnd = false; } };

Solution

1. Step 1: Check children type for TrieNode

   Children must be pointers to TrieNode to allow dynamic node creation; hence TrieNode* children[26].

2. Step 2: Verify initialization

   Initialize all children pointers to nullptr and isEnd to false in constructor.

3. Final Answer:

   class TrieNode { public: TrieNode* children[26]; bool isEnd; TrieNode() { for(int i=0; i<26; i++) children[i] = nullptr; isEnd = false; } }; -> Option D

4. Quick Check:

   Children pointers + init nullptr = class TrieNode { public: TrieNode* children[26]; bool isEnd; TrieNode() { for(int i=0; i<26; i++) children[i] = nullptr; isEnd = false; } }; [OK]

Hint: Children must be pointers, initialized to nullptr [OK]

Common Mistakes:

• Using int array instead of pointers
• Not initializing children to nullptr
• Using vector<char> instead of TrieNode pointers

3. What will be the output of the following code snippet after inserting the words "cat" and "car" into an empty Trie?

Trie trie;
trie.insert("cat");
trie.insert("car");
int count = 0;
for(int i = 0; i < 26; i++) {
  if(trie.root->children[i] != nullptr) count++;
}
std::cout << count << std::endl;

medium

A. 1

B. 2

C. 3

D. 0

Solution

1. Step 1: Insert "cat" and "car" into Trie

   Both words start with 'c', so only one child node for 'c' is created at root.

2. Step 2: Count root children nodes

   Only one child at root for 'c' exists, so count is 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Root children count after insert = 1 [OK]

Hint: Count root children after insert; common prefix shares node [OK]

Common Mistakes:

• Counting all characters instead of root children
• Assuming separate root nodes for each word
• Confusing total nodes with root children

4. Identify the error in the following Trie insert function snippet:

void insert(string word) {
  TrieNode* node = root;
  for(char c : word) {
    int index = c - 'a';
    if(node->children[index] == NULL) {
      node->children[index] = new TrieNode();
    }
    node = node->children[index];
  }
  node->isEnd = true;
}

medium

A. No error; the insert function is correct

B. The index calculation should be c - 'A' instead of c - 'a'

C. The root pointer is not initialized before insertion

D. The loop should iterate over indices, not characters

Solution

1. Step 1: Check root initialization assumption

   Assuming root is properly initialized elsewhere, this code correctly uses root pointer.

2. Step 2: Verify index calculation and loop

   Index c - 'a' is correct for lowercase letters; loop over characters is valid.

3. Final Answer:

   No error; the insert function is correct -> Option A

4. Quick Check:

   Code logic matches standard insert [OK]

Hint: Check index and pointer usage carefully [OK]

Common Mistakes:

• Assuming uppercase letters without context
• Thinking loop must use indices
• Forgetting root initialization outside snippet

5. Given a Trie that already contains the words "bat", "ball", and "barn", what will be the effect of inserting the word "bar"?
Choose the correct statement.

hard

A. A new branch is created starting from 'b' node

B. No new nodes are created; only an existing node's isEnd flag is set

C. All existing nodes are duplicated to insert the new word

D. The word "bar" cannot be inserted because "barn" exists

Solution

1. Step 1: Analyze existing Trie structure

   Words "bat", "ball", "barn" share prefix 'ba' and 'bar' prefix exists as part of "barn".

2. Step 2: Effect of inserting "bar"

   Nodes for 'b', 'a', 'r' already exist; only isEnd flag at 'r' node is set to true to mark "bar" as a word.

3. Final Answer:

   No new nodes are created; only an existing node's isEnd flag is set -> Option B

4. Quick Check:

   Insert existing prefix sets isEnd only [OK]

Hint: Insert existing prefix sets isEnd flag only [OK]

Common Mistakes:

• Thinking new nodes are always created
• Assuming duplicates of nodes happen
• Believing insertion fails if prefix exists