Design Search Autocomplete System - Practice Coding Problems

Design Search Autocomplete System - Problem

String Depth-First Search Design Trie Sorting Heap (Priority Queue) Data Stream Hard

Imagine building the autocomplete system for a major search engine like Google! Your task is to create an intelligent system that suggests the most relevant search queries as users type.

You'll implement an AutocompleteSystem class that:

Learns from historical search data - both the sentences and how many times each was searched
Provides real-time suggestions as users type character by character
Returns the top 3 hottest matching sentences based on search frequency
Handles tie-breaking using ASCII order (lexicographical)
Completes searches when users type the special character '#'

Example: If historical data shows "i love you" was searched 5 times and "island" was searched 3 times, then typing "i" should return both suggestions, with "i love you" ranked higher due to its popularity.

The system must be responsive and intelligent, just like the autocomplete you use every day!

Input & Output

example_1.py — Basic Usage

$ Input: sentences = ["i love you", "island", "i love leetcode"], times = [5, 3, 2] Input sequence: 'i', ' ', 'a', '#'

› Output: ['i love you', 'island', 'i love leetcode'] → ['i love you', 'i love leetcode'] → [] → []

💡 Note: Initially 'i' matches all three sentences, sorted by frequency. After space, only sentences with 'i ' prefix match. 'a' has no matches. '#' ends input and returns empty list.

example_2.py — New Sentence Addition

$ Input: sentences = ["i love you", "island"], times = [5, 3] Input sequence: 'i', '#', 'i', ' ', 'a', '#', 'i', ' ', 'a'

› Output: ['i love you', 'island'] → [] → ['i love you', 'island'] → ['i love you'] → [] → ['i love you', 'i a']

💡 Note: After typing 'i#', the sentence 'i' is added with frequency 1. After 'i a#', the sentence 'i a' is added. Both new sentences appear in subsequent searches.

example_3.py — ASCII Ordering

$ Input: sentences = ["abc", "abd", "abe"], times = [2, 2, 2] Input sequence: 'a', 'b'

› Output: ['abc', 'abd', 'abe'] → ['abc', 'abd', 'abe']

💡 Note: All sentences have the same frequency (2), so they are returned in ASCII (lexicographical) order: 'abc' < 'abd' < 'abe'.

Visualization

Tap to expand

Understanding the Visualization

Data Ingestion

Historical search data (sentences and frequencies) is processed and stored in an efficient Trie structure

Real-time Processing

Each character typed navigates deeper into the Trie, instantly accessing pre-computed suggestions

Smart Ranking

Results are ranked by popularity (search frequency) with alphabetical tie-breaking

Learning System

New searches (ending with '#') are added to the system, continuously improving suggestions

Key Takeaway

🎯 Key Insight: Using a Trie with pre-sorted sentence lists at each node transforms expensive search operations into instant lookups, making it perfect for real-time autocomplete systems that need to handle millions of queries efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(m + k log k)

m is prefix length to navigate Trie, k log k for priority queue operations on matching sentences

⚡ Linearithmic

Space Complexity

O(ALPHABET_SIZE × N × M)

Trie storage where N is number of sentences, M is average length, ALPHABET_SIZE is character set size

✓ Linear Space

Constraints

1 ≤ sentences.length ≤ 100
1 ≤ sentences[i].length ≤ 100
1 ≤ times[i] ≤ 50
At most 5000 calls will be made to input
Each character in input will be a lowercase English letter, space ' ', or '#'
Sentences will only contain lowercase English letters and spaces

Asked in

G Google 75 a Amazon 50 f Meta 40 ⊞ Microsoft 35

The optimal solution uses a Trie (prefix tree) data structure combined with efficient sorting. Each Trie node stores a list of sentences that pass through it along with their frequencies. This enables O(m) prefix matching where m is the prefix length, and instant retrieval of the top 3 suggestions. The key insight is preprocessing sentences at each node to avoid expensive searching and sorting during queries, making it perfect for real-time autocomplete systems.

Common Approaches

Approach	Time	Space	Notes
✓ Trie + Priority Queue (Optimal)	O(m + k log k)	O(ALPHABET_SIZE × N × M)	Use Trie data structure with efficient prefix matching and priority queue for top-k results
Brute Force (Linear Search)	O(n * m * log k)	O(n * m)	Store all sentences and search through them linearly for each input

Trie + Priority Queue (Optimal) — Algorithm Steps

Build a Trie where each node stores sentences passing through it
For each input character, navigate to the corresponding Trie node
Use a priority queue to efficiently maintain top 3 results by frequency and ASCII order
Return the top 3 sentences from the current node
Handle '#' by adding new sentences to the Trie structure

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Insert all sentences into Trie, storing frequency data at each node

Navigate Prefix

Follow Trie path for current input prefix

Get Suggestions

Retrieve pre-sorted sentences from current Trie node

Return Top 3

Return top 3 suggestions instantly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CHILDREN 128
#define MAX_SENTENCES 100
#define MAX_LEN 1000

typedef struct TrieNode {
    struct TrieNode* children[MAX_CHILDREN];
    char sentences[MAX_SENTENCES][MAX_LEN];
    int frequencies[MAX_SENTENCES];
    int sentenceCount;
} TrieNode;

typedef struct {
    TrieNode* root;
    TrieNode* currentNode;
    char currentInput[MAX_LEN];
    int currentLen;
} AutocompleteSystem;

TrieNode* createTrieNode() {
    TrieNode* node = (TrieNode*)calloc(1, sizeof(TrieNode));
    return node;
}

void addSentenceToTrie(TrieNode* root, char* sentence, int frequency) {
    TrieNode* node = root;
    int len = strlen(sentence);
    
    for (int i = 0; i < len; i++) {
        int index = (int)sentence[i];
        if (node->children[index] == NULL) {
            node->children[index] = createTrieNode();
        }
        node = node->children[index];
        
        // Update frequency
        int found = -1;
        for (int j = 0; j < node->sentenceCount; j++) {
            if (strcmp(node->sentences[j], sentence) == 0) {
                found = j;
                break;
            }
        }
        
        if (found >= 0) {
            node->frequencies[found] += frequency;
        } else if (node->sentenceCount < MAX_SENTENCES) {
            strcpy(node->sentences[node->sentenceCount], sentence);
            node->frequencies[node->sentenceCount] = frequency;
            node->sentenceCount++;
        }
        
        // Simple bubble sort for small arrays
        for (int j = 0; j < node->sentenceCount - 1; j++) {
            for (int k = 0; k < node->sentenceCount - 1 - j; k++) {
                if (node->frequencies[k] < node->frequencies[k + 1] ||
                    (node->frequencies[k] == node->frequencies[k + 1] && 
                     strcmp(node->sentences[k], node->sentences[k + 1]) > 0)) {
                    // Swap
                    int tempFreq = node->frequencies[k];
                    char tempSent[MAX_LEN];
                    strcpy(tempSent, node->sentences[k]);
                    
                    node->frequencies[k] = node->frequencies[k + 1];
                    strcpy(node->sentences[k], node->sentences[k + 1]);
                    
                    node->frequencies[k + 1] = tempFreq;
                    strcpy(node->sentences[k + 1], tempSent);
                }
            }
        }
    }
}

AutocompleteSystem* autocompleteSystemCreate(char** sentences, int sentencesSize, int* times, int timesSize) {
    AutocompleteSystem* obj = (AutocompleteSystem*)malloc(sizeof(AutocompleteSystem));
    obj->root = createTrieNode();
    obj->currentNode = obj->root;
    obj->currentLen = 0;
    obj->currentInput[0] = '\0';
    
    for (int i = 0; i < sentencesSize; i++) {
        addSentenceToTrie(obj->root, sentences[i], times[i]);
    }
    
    return obj;
}

char** autocompleteSystemInput(AutocompleteSystem* obj, char c, int* returnSize) {
    if (c == '#') {
        if (obj->currentLen > 0) {
            addSentenceToTrie(obj->root, obj->currentInput, 1);
        }
        obj->currentLen = 0;
        obj->currentInput[0] = '\0';
        obj->currentNode = obj->root;
        *returnSize = 0;
        return NULL;
    }
    
    obj->currentInput[obj->currentLen] = c;
    obj->currentLen++;
    obj->currentInput[obj->currentLen] = '\0';
    
    if (obj->currentNode && obj->currentNode->children[(int)c]) {
        obj->currentNode = obj->currentNode->children[(int)c];
        
        char** result = (char**)malloc(3 * sizeof(char*));
        int count = obj->currentNode->sentenceCount < 3 ? obj->currentNode->sentenceCount : 3;
        
        for (int i = 0; i < count; i++) {
            result[i] = (char*)malloc(MAX_LEN * sizeof(char));
            strcpy(result[i], obj->currentNode->sentences[i]);
        }
        
        *returnSize = count;
        return result;
    } else {
        obj->currentNode = NULL;
        *returnSize = 0;
        return NULL;
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(m + k log k)

m is prefix length to navigate Trie, k log k for priority queue operations on matching sentences

⚡ Linearithmic

Space Complexity

O(ALPHABET_SIZE × N × M)

Trie storage where N is number of sentences, M is average length, ALPHABET_SIZE is character set size

✓ Linear Space

Constraints

1 ≤ sentences.length ≤ 100
1 ≤ sentences[i].length ≤ 100
1 ≤ times[i] ≤ 50
At most 5000 calls will be made to input
Each character in input will be a lowercase English letter, space ' ', or '#'
Sentences will only contain lowercase English letters and spaces

127.5K Views

Very High Frequency

~35 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Trie + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler