Prefix matching with tries in Data Structures Theory - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a trie in data structures?

A trie is a tree-like data structure used to store a dynamic set of strings where keys are usually strings. It allows fast retrieval of words by their prefixes.

beginner

How does prefix matching work in a trie?

Prefix matching in a trie works by following the path of characters from the root node down to the node that represents the last character of the prefix. All words below that node share the prefix.

intermediate

Why are tries efficient for prefix matching compared to other data structures?

Tries are efficient because they share common prefixes among keys, reducing redundant comparisons and allowing prefix searches in time proportional to the prefix length, not the number of stored words.

intermediate

What is the space trade-off when using tries for prefix matching?

Tries can use more memory than other structures because each node may have multiple children, even if many are empty. This overhead is the trade-off for faster prefix searches.

beginner

Give a real-life example where prefix matching with tries is useful.

Autocomplete in search engines or phone keyboards uses tries to quickly find all words starting with the typed prefix, improving user experience by suggesting possible completions.

What does each node in a trie typically represent?

A A whole word

B A character in a string

C A number

D A sentence

Each node in a trie represents a single character of a string, allowing traversal to form words.

What is the main advantage of using a trie for prefix matching?

A Faster search based on prefix length

B Less memory usage than arrays

C Stores numbers efficiently

D Automatically sorts words alphabetically

Tries allow searching prefixes in time proportional to the prefix length, making prefix matching fast.

Which of the following is a disadvantage of tries?

A Slow prefix search

B Cannot store strings

C High memory usage

D No support for prefix matching

Tries can use more memory because each node may have many children, even if some are unused.

In prefix matching, what does the trie node at the end of the prefix represent?

A The start of all words with that prefix

B The end of all words with that prefix

C The middle character of the prefix

D A random character

The node at the end of the prefix marks the start of all words sharing that prefix.

Which real-world application commonly uses prefix matching with tries?

A Image compression

B Video streaming

C Sorting numbers

D Autocomplete suggestions

Autocomplete uses tries to quickly find words starting with the typed prefix.

Explain how a trie helps in finding all words that start with a given prefix.

Think about how you follow letters one by one in the trie.

Describe the main advantages and disadvantages of using tries for prefix matching.

Consider speed versus memory.

Practice

1. What is the main advantage of using a trie for prefix matching?

easy

A. It stores words in reverse order

B. It uses less memory than arrays

C. It sorts words alphabetically automatically

D. It allows fast lookup of words sharing common prefixes

Solution

1. Step 1: Understand trie structure

   A trie stores words by sharing nodes for common prefixes, reducing repeated storage.

2. Step 2: Identify prefix matching benefit

   This structure allows quick traversal to find all words starting with a given prefix.

3. Final Answer:

   It allows fast lookup of words sharing common prefixes -> Option D

4. Quick Check:

   Prefix matching speed = Fast lookup [OK]

Hint: Tries speed up prefix search by sharing nodes [OK]

Common Mistakes:

• Confusing tries with hash tables
• Thinking tries sort words automatically
• Assuming tries store words backwards

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

easy

A. Search the entire trie for the full word

B. Traverse nodes matching each prefix character until end or mismatch

C. Count all leaf nodes in the trie

D. Sort all words and do binary search

Solution

1. Step 1: Understand prefix search in tries

   To check a prefix, we walk down the trie nodes matching each character in order.

2. Step 2: Identify correct method

   If traversal completes without mismatch, prefix exists; otherwise, it does not.

3. Final Answer:

   Traverse nodes matching each prefix character until end or mismatch -> Option B

4. Quick Check:

   Prefix check = Node traversal [OK]

Hint: Walk trie nodes character by character for prefix [OK]

Common Mistakes:

• Searching entire trie instead of prefix path
• Counting leaf nodes unrelated to prefix
• Using sorting instead of trie traversal

3. Given a trie containing words: ['cat', 'car', 'cart', 'dog'], which words match the prefix 'car'?

medium

A. ['car', 'cart']

B. ['dog']

C. ['cat', 'car']

D. ['cat', 'dog']

Solution

1. Step 1: Identify words starting with 'car'

   From the list, 'car' and 'cart' start with the prefix 'car'.

2. Step 2: Exclude words not matching prefix

   'cat' starts with 'cat', not 'car'; 'dog' does not match prefix.

3. Final Answer:

   ['car', 'cart'] -> Option A

4. Quick Check:

   Words with prefix 'car' = ['car', 'cart'] [OK]

Hint: Match prefix exactly to filter words [OK]

Common Mistakes:

• Including words with similar but different prefixes
• Confusing 'cat' with 'car'
• Selecting unrelated words

4. A trie implementation returns false when checking prefix 'app' even though words ['apple', 'application'] exist. What is the most likely error?

medium

A. The trie nodes for 'app' were not linked correctly

B. The words were inserted backwards

C. The prefix check is case-insensitive

D. The trie only stores full words, not prefixes

Solution

1. Step 1: Analyze prefix check failure

   If words with prefix 'app' exist but check fails, likely the path for 'app' nodes is broken.

2. Step 2: Exclude other causes

   Words inserted backwards or case issues would cause different errors; tries store prefixes inherently.

3. Final Answer:

   The trie nodes for 'app' were not linked correctly -> Option A

4. Quick Check:

   Broken node links = prefix check fail [OK]

Hint: Check node links for prefix path [OK]

Common Mistakes:

• Assuming tries don't store prefixes
• Ignoring node linkage errors
• Confusing case sensitivity issues

5. You want to build an autocomplete feature using a trie. Which approach best improves performance when many words share prefixes?

hard

A. Use a linked list instead of trie nodes for each character

B. Store full words only at leaf nodes without intermediate nodes

C. Store a count of words passing through each node to quickly find popular prefixes

D. Sort all words and do linear search for each prefix

Solution

1. Step 1: Understand autocomplete with tries

   Autocomplete benefits from knowing how many words share a prefix to prioritize suggestions.

2. Step 2: Identify performance improvement

   Storing counts at each node helps quickly find popular prefixes without full traversal.

3. Final Answer:

   Store a count of words passing through each node to quickly find popular prefixes -> Option C

4. Quick Check:

   Node counts = faster autocomplete [OK]

Hint: Count words at nodes to speed autocomplete [OK]

Common Mistakes:

• Storing words only at leaves slows prefix search
• Using linked lists reduces trie efficiency
• Linear search ignores trie benefits