Trie vs Hash Map for Prefix Matching in DSA Java - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of prefix search using Trie

What is the output of the following Java code that inserts words into a Trie and searches for a prefix?

DSA Java

class TrieNode {
    TrieNode[] children = new TrieNode[26];
    boolean isEnd = false;
}

class Trie {
    TrieNode root = new TrieNode();

    void insert(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            int idx = c - 'a';
            if (node.children[idx] == null) {
                node.children[idx] = new TrieNode();
            }
            node = node.children[idx];
        }
        node.isEnd = true;
    }

    boolean startsWith(String prefix) {
        TrieNode node = root;
        for (char c : prefix.toCharArray()) {
            int idx = c - 'a';
            if (node.children[idx] == null) return false;
            node = node.children[idx];
        }
        return true;
    }
}

public class Main {
    public static void main(String[] args) {
        Trie trie = new Trie();
        trie.insert("apple");
        trie.insert("app");
        System.out.println(trie.startsWith("app"));
        System.out.println(trie.startsWith("apl"));
    }
}

A

false
true

B

true
false

C

false
false

D

true
true

💡 Hint

Think about whether the prefix exists in the inserted words.

The prefix "app" exists in the Trie because "apple" and "app" were inserted. The prefix "apl" does not exist, so the output is true then false.

🧠 Conceptual

intermediate

Why use Trie over Hash Map for prefix matching?

Which of the following is the main advantage of using a Trie over a Hash Map for prefix matching?

A Trie allows efficient prefix search without checking all keys

B Hash Map uses less memory than Trie for prefix matching

C Trie cannot store multiple words with common prefixes

D Hash Map supports prefix search faster than Trie

💡 Hint

Think about how prefix search works in both data structures.

Trie stores words in a tree structure where common prefixes share nodes, allowing efficient prefix search. Hash Map requires checking all keys or additional structures.

🔧 Debug

advanced

Identify the error in Hash Map prefix search code

What error will occur when running this Java code that tries to find keys with a prefix using a Hash Map?

DSA Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("app", 2);
        map.put("banana", 3);

        for (String key : map.keySet()) {
            if (key.startsWith("app")) {
                System.out.println(key + ": " + map.get(key));
            }
        }
    }
}

A SyntaxError due to missing semicolon

B NullPointerException at map.get(key)

C ConcurrentModificationException during iteration

D No error; prints keys starting with "app"

💡 Hint

Check if the code modifies the map during iteration.

The code iterates over keys and prints those starting with "app" without modifying the map, so no error occurs.

❓ Predict Output

advanced

Output of prefix search using Hash Map keys

What is the output of this Java code that uses a Hash Map to find keys starting with a prefix?

DSA Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("cat", 1);
        map.put("car", 2);
        map.put("dog", 3);

        List<String> result = new ArrayList<>();
        for (String key : map.keySet()) {
            if (key.startsWith("ca")) {
                result.add(key);
            }
        }
        Collections.sort(result);
        System.out.println(result);
    }
}

A [car, cat]

B [cat, dog]

C [car, dog]

D [dog]

💡 Hint

Check which keys start with "ca" and the sorting order.

Keys "car" and "cat" start with "ca". After sorting alphabetically, the list is [car, cat].

🧠 Conceptual

expert

Memory usage comparison between Trie and Hash Map for prefix matching

Which statement best describes the memory usage difference between Trie and Hash Map when storing many words with common prefixes?

A Trie always uses more memory due to storing child arrays for each node

B Hash Map uses less memory because it stores keys as references only

C Trie uses less memory by sharing nodes for common prefixes, Hash Map stores full keys separately

D Both use the same memory since they store the same words

💡 Hint

Think about how common prefixes are stored in Trie vs Hash Map.

Trie shares nodes for common prefixes, reducing memory for overlapping parts. Hash Map stores each key string fully, increasing memory when many keys share prefixes.

Practice

1. Which data structure is generally more efficient for prefix matching in a large set of strings?

easy

A. Array, because it stores elements in order and allows binary search

B. Trie, because it stores characters in a tree structure allowing fast prefix search

C. Hash Map, because it stores keys with direct access and no traversal

D. Linked List, because it allows sequential access to all elements

Solution

1. Step 1: Understand prefix matching requirement

   Prefix matching means finding all strings starting with a given prefix quickly.

2. Step 2: Compare Trie and Hash Map for prefix search

   Trie stores characters in nodes linked by edges, allowing traversal by prefix. Hash Map requires checking all keys or storing prefixes separately, which is less efficient.

3. Final Answer:

   Trie, because it stores characters in a tree structure allowing fast prefix search -> Option B

4. Quick Check:

   Trie = Fast prefix search [OK]

Hint: Trie is designed for prefix search, hash map is not [OK]

Common Mistakes:

• Thinking hash map can do prefix search directly
• Confusing array or linked list with prefix search efficiency

2. Which of the following is the correct way to check if a prefix exists in a Trie in Java?

easy

A. Use a loop to traverse nodes for each character of the prefix and check if nodes exist

B. Use HashMap.containsKey(prefix) directly on the Trie root

C. Use binary search on the Trie nodes array

D. Use recursion to check if prefix is a substring of any word

Solution

1. Step 1: Understand Trie prefix search method

   To check prefix, we traverse the Trie nodes character by character along the prefix path.

2. Step 2: Evaluate options for prefix check

   Use a loop to traverse nodes for each character of the prefix and check if nodes exist correctly describes traversal. Use HashMap.containsKey(prefix) directly on the Trie root is incorrect because HashMap.containsKey checks full keys, not prefixes. Use binary search on the Trie nodes array and D do not apply to Trie structure.

3. Final Answer:

   Use a loop to traverse nodes for each character of the prefix and check if nodes exist -> Option A

4. Quick Check:

   Traverse nodes for prefix = Use a loop to traverse nodes for each character of the prefix and check if nodes exist [OK]

Hint: Traverse Trie nodes for each prefix character [OK]

Common Mistakes:

• Using HashMap.containsKey for prefix check
• Trying binary search on Trie nodes
• Confusing substring with prefix

3. Given the following Java Trie code snippet, what will be the output after inserting words "cat", "car", "dog" and checking prefix "ca"?

Trie trie = new Trie();
trie.insert("cat");
trie.insert("car");
trie.insert("dog");
boolean result = trie.startsWith("ca");
System.out.println(result);

medium

A. Compilation error

B. false

C. true

D. Runtime exception

Solution

1. Step 1: Insert words into Trie

   Words "cat", "car", and "dog" are inserted, creating nodes for 'c', 'a', 't', 'r', 'd', 'o', 'g'.

2. Step 2: Check prefix "ca"

   Prefix "ca" matches nodes 'c' and 'a' in the Trie, so startsWith returns true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Prefix "ca" exists = true [OK]

Hint: Inserted words with prefix "ca" means startsWith("ca") is true [OK]

Common Mistakes:

• Assuming startsWith returns false if prefix is not a full word
• Confusing startsWith with search for full word
• Expecting compilation or runtime errors

4. Consider this Java code snippet using a HashMap to store words and check prefixes:

HashMap map = new HashMap<>();
map.put("apple", true);
map.put("app", true);
boolean prefixExists = map.containsKey("ap");
System.out.println(prefixExists);

What is the output and why?

medium

A. false, because "ap" is not a key in the map

B. true, because "ap" is a prefix of "app" and "apple"

C. Compilation error due to wrong HashMap usage

D. Runtime exception due to null key

Solution

1. Step 1: Understand HashMap key storage

   HashMap stores exact keys "apple" and "app", but not "ap".

2. Step 2: Check containsKey("ap")

   containsKey checks for exact key match, so returns false for "ap".

3. Final Answer:

   false, because "ap" is not a key in the map -> Option A

4. Quick Check:

   HashMap exact key check = false for "ap" [OK]

Hint: HashMap keys must match exactly, no prefix matching [OK]

Common Mistakes:

• Assuming containsKey checks prefixes
• Expecting true because "ap" is prefix of stored keys
• Confusing HashMap with Trie behavior

5. You need to implement a system that supports fast prefix queries on millions of words and also allows quick insertion and deletion. Which data structure is best suited and why?

hard

A. ArrayList, because it allows fast insertion and deletion at the end

B. Hash Map, because it provides constant time insertion and deletion

C. Balanced Binary Search Tree, because it keeps data sorted for prefix search

D. Trie, because it supports efficient prefix queries and dynamic updates

Solution

1. Step 1: Analyze prefix query requirement

   Fast prefix queries require a data structure that can traverse prefixes efficiently.

2. Step 2: Compare data structures for insertion, deletion, and prefix search

   Trie supports prefix queries efficiently and allows insertion/deletion by node updates. Hash Map is fast for exact keys but not prefix queries. Balanced BST supports sorted data but prefix search is slower. ArrayList is inefficient for prefix queries and deletions.

3. Final Answer:

   Trie, because it supports efficient prefix queries and dynamic updates -> Option D

4. Quick Check:

   Trie = best for prefix queries + updates [OK]

Hint: Trie handles prefix queries and updates efficiently [OK]

Common Mistakes:

• Choosing Hash Map for prefix queries
• Assuming balanced BST is best for prefix search
• Ignoring deletion complexity in ArrayList