Why Trie Exists and What Hash Map Cannot Do for Strings in DSA Go - Quick Recap

Recall & Review

beginner

What is a Trie and why is it used for strings?

A Trie is a tree-like data structure that stores strings by sharing common prefixes. It is used to efficiently search, insert, and retrieve strings, especially when many strings share prefixes.

beginner

Why can't a Hash Map efficiently handle prefix-based string queries?

Hash Maps use hashing which treats each string as a whole key. They cannot efficiently find all strings sharing a prefix because hashing does not preserve prefix relationships.

intermediate

How does a Trie improve prefix search compared to a Hash Map?

A Trie stores characters in nodes along paths representing prefixes. This allows quick traversal to all strings sharing a prefix, unlike Hash Maps which require checking each key separately.

intermediate

What is a real-life example where Trie is better than Hash Map for strings?

Autocomplete in search engines uses Trie to quickly find all words starting with typed letters. Hash Maps cannot efficiently find all such words because they lack prefix structure.

intermediate

What is a limitation of Hash Maps when storing many strings with common prefixes?

Hash Maps store each string independently, causing repeated storage of common prefixes and inefficient prefix queries. Tries share prefix nodes, saving space and time.

What data structure is best for efficient prefix searches on strings?

A Trie

B Hash Map

C Stack

D Queue

Trie stores strings by prefixes, enabling fast prefix searches unlike Hash Maps.

Why can't Hash Maps efficiently find all strings starting with a prefix?

A They only store numbers

B They do not store prefix relationships

C They are too slow

D They use trees internally

Hash Maps treat keys as whole strings, losing prefix information.

Which of these is a key advantage of Trie over Hash Map for strings?

A Faster hashing

B Less memory for all data types

C Shared prefix storage

D Supports duplicate keys

Trie nodes share prefixes, saving space and enabling prefix queries.

In which scenario is Trie most useful?

A Storing unrelated data

B Counting unique numbers

C Sorting integers

D Autocomplete suggestions

Autocomplete needs prefix search, which Trie supports efficiently.

What happens if you use a Hash Map to find all strings with a prefix?

A You must check all keys individually

B It returns results instantly

C It sorts keys automatically

D It groups keys by prefix

Hash Maps do not group keys by prefix, so all keys must be checked.

Explain why Trie is preferred over Hash Map for prefix-based string operations.

Think about how each data structure handles parts of strings.

Describe a real-world use case where Trie is more efficient than Hash Map for strings.

Consider typing in a search box.

Practice

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

easy

A. Because Trie can efficiently find all strings with a common prefix

B. Because Hash Map uses less memory than Trie

C. Because Trie stores strings as keys directly without nodes

D. Because Hash Map automatically sorts strings alphabetically

Solution

1. Step 1: Understand Trie prefix search

   Trie stores strings in a tree form where each node represents a character, allowing quick prefix searches.

2. Step 2: Compare with Hash Map capabilities

   Hash Map stores full strings as keys but cannot efficiently find all strings sharing a prefix without checking all keys.

3. Final Answer:

   Because Trie can efficiently find all strings with a common prefix -> Option A

4. Quick Check:

   Trie = Efficient prefix search [OK]

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

Common Mistakes:

• Thinking Hash Map sorts keys automatically
• Believing Trie uses less memory always
• Confusing Trie nodes with full string keys

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

easy

A. type TrieNode struct { children map[string]int; isEnd int }

B. type TrieNode struct { children []int; isEnd string }

C. type TrieNode struct { children map[rune]*TrieNode; isEnd bool }

D. type TrieNode struct { children map[int]string; isEnd bool }

Solution

1. Step 1: Identify correct children type for TrieNode

   Children should map characters (rune) to child nodes (pointer to TrieNode).

2. Step 2: Check isEnd field type

   isEnd should be a boolean indicating if node marks end of a word.

3. Final Answer:

   type TrieNode struct { children map[rune]*TrieNode; isEnd bool } -> Option C

4. Quick Check:

   Children map[rune]*TrieNode and isEnd bool [OK]

Hint: Children map keys are runes, isEnd is bool [OK]

Common Mistakes:

• Using wrong map key or value types
• Setting isEnd as string or int instead of bool
• Using slice instead of map for children

3. What will be the output of the following Go code snippet?

type TrieNode struct {
  children map[rune]*TrieNode
  isEnd bool
}

func main() {
  root := &TrieNode{children: make(map[rune]*TrieNode)}
  word := "cat"
  node := root
  for _, ch := range word {
    if node.children[ch] == nil {
      node.children[ch] = &TrieNode{children: make(map[rune]*TrieNode)}
    }
    node = node.children[ch]
  }
  node.isEnd = true
  
  // Check if 'car' is in Trie
  node = root
  checkWord := "car"
  found := true
  for _, ch := range checkWord {
    if node.children[ch] == nil {
      found = false
      break
    }
    node = node.children[ch]
  }
  if found && node.isEnd {
    println("Found")
  } else {
    println("Not Found")
  }
}

medium

A. Found

B. Not Found

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Insert 'cat' into Trie

   The code adds nodes for 'c', 'a', 't' and marks 't' node as end of word.

2. Step 2: Search for 'car' in Trie

   Traversal finds 'c' and 'a' nodes but no child for 'r', so found becomes false.

3. Final Answer:

   Not Found -> Option B

4. Quick Check:

   Only 'cat' inserted, 'car' missing last node [OK]

Hint: Check each character node; missing means Not Found [OK]

Common Mistakes:

• Assuming partial prefix means found
• Confusing isEnd flag usage
• Expecting runtime errors from nil map access

4. The following Go code tries to insert a word into a Trie but causes a runtime panic. What is the error?

type TrieNode struct {
  children map[rune]*TrieNode
  isEnd bool
}

func insert(root *TrieNode, word string) {
  node := root
  for _, ch := range word {
    if node.children[ch] == nil {
      node.children[ch] = &TrieNode{}
    }
    node = node.children[ch]
  }
  node.isEnd = true
}

func main() {
  root := &TrieNode{}
  insert(root, "dog")
}

medium

A. children map is not initialized before use

B. isEnd should be an int, not bool

C. Function insert missing return type

D. root pointer is nil

Solution

1. Step 1: Check initialization of children map

   Root node's children map is nil because it was not created with make(), causing panic on access.

2. Step 2: Understand panic cause

   Accessing or assigning to nil map causes runtime panic in Go.

3. Final Answer:

   children map is not initialized before use -> Option A

4. Quick Check:

   Nil map access causes panic [OK]

Hint: Always initialize maps with make() before use [OK]

Common Mistakes:

• Ignoring map initialization
• Thinking isEnd type causes panic
• Assuming nil pointer for root

5. You want to find all words in a large dictionary that start with the prefix "pre". Why is a Trie better than a Hash Map for this task, and how would you implement the search?

hard

A. Trie uses hashing internally to speed up prefix search

B. Hash Map sorts keys internally, so prefix search is a simple range query

C. Hash Map stores words as linked lists, making prefix search faster

D. Trie stores words by prefix nodes, allowing direct traversal to prefix end; then collect all descendant words

Solution

1. Step 1: Understand Trie prefix traversal

   In Trie, each character is a node; to find prefix "pre", traverse nodes 'p' -> 'r' -> 'e'.

2. Step 2: Collect all words under prefix node

   From the 'e' node, recursively collect all words by exploring child nodes marking word ends.

3. Final Answer:

   Trie stores words by prefix nodes, allowing direct traversal to prefix end; then collect all descendant words -> Option D

4. Quick Check:

   Trie = Direct prefix traversal + collect descendants [OK]

Hint: Traverse prefix nodes, then gather all child words [OK]

Common Mistakes:

• Assuming Hash Map sorts keys automatically
• Thinking Trie uses hashing internally
• Confusing linked list with Hash Map storage