All O`one Data Structure

All O`one Data Structure - Problem

Design a powerful data structure that tracks string frequencies and provides instant access to both the most and least frequent strings!

You need to implement the AllOne class with these operations:

AllOne(): Initialize the data structure
inc(String key): Increment the count of key by 1. If the key doesn't exist, insert it with count 1
dec(String key): Decrement the count of key by 1. If the count becomes 0, remove the key completely
getMaxKey(): Return any key with the maximum count (or empty string if none exist)
getMinKey(): Return any key with the minimum count (or empty string if none exist)

The Challenge: All operations must run in O(1) average time complexity! This means you can't simply iterate through all keys to find min/max.

Input & Output

example_1.py — Basic Operations

$ Input: ["AllOne", "inc", "inc", "getMaxKey", "getMinKey", "inc", "getMaxKey", "getMinKey"] [[], ["hello"], ["hello"], [], [], ["leet"], [], []]

› Output: [null, null, null, "hello", "hello", null, "hello", "leet"]

💡 Note: Initialize AllOne, increment "hello" twice (count=2), then add "leet" once (count=1). "hello" has max count, "leet" has min count.

example_2.py — Decrement Operations

$ Input: ["AllOne", "inc", "inc", "inc", "dec", "getMaxKey", "getMinKey"] [[], ["a"], ["b"], ["b"], ["b"], [], []]

› Output: [null, null, null, null, null, "b", "a"]

💡 Note: After operations: "a" has count 1, "b" has count 2 (incremented twice, decremented once). "b" is max, "a" is min.

example_3.py — Edge Case Empty

$ Input: ["AllOne", "getMaxKey", "getMinKey", "inc", "dec", "getMaxKey", "getMinKey"] [[], [], [], ["test"], ["test"], [], []]

› Output: [null, "", "", null, null, "", ""]

💡 Note: Initially empty, so getMaxKey/getMinKey return empty strings. After inc then dec "test", it's removed, so empty again.

Constraints

1 ≤ key.length ≤ 10
key consists of lowercase English letters
At most 5 × 10⁴ calls will be made to inc, dec, getMaxKey, and getMinKey
All function calls must have O(1) average time complexity

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28

The optimal solution combines a hash map for O(1) key lookup with a doubly-linked list of frequency nodes for O(1) min/max access. Each frequency node contains all keys with that count, maintaining sorted order automatically while enabling all operations in O(1) time.

Common Approaches

✓ Hash Map + Doubly Linked List (Optimal)

⏱️ Time: O(1) Space: O(n)

Use a hash map to store key-to-node mappings and a doubly-linked list where each node represents a frequency level containing all keys with that count. This allows O(1) access to both data and frequency ordering.

Naive Hash Map Only

⏱️ Time: O(n) Space: O(n)

Use a simple hash map to store key counts. For getMaxKey() and getMinKey(), iterate through all entries to find the maximum and minimum counts.

Hash Map + Doubly Linked List (Optimal) — Algorithm Steps

Create a doubly-linked list where each node represents a frequency level
Each frequency node contains a set of keys with that frequency
Use a hash map to directly map each key to its frequency node
For inc/dec: move keys between frequency nodes, create/delete nodes as needed
For getMaxKey/getMinKey: access head/tail nodes directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Structure

Empty doubly-linked list with dummy head/tail

Add Keys

Keys grouped by frequency in sorted order

Update Operations

Move keys between frequency levels in O(1)

Min/Max Access

Instant access to head/tail frequency nodes

Code -

solution.c — C

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

#define MAX_KEYS 1000
#define MAX_FREQ_NODES 1000

typedef struct FreqNode {
    int count;
    char keys[MAX_KEYS][100];
    int keyCount;
    struct FreqNode* prev;
    struct FreqNode* next;
} FreqNode;

typedef struct {
    char keyToFreq[MAX_KEYS][100];
    FreqNode* keyToNode[MAX_KEYS];
    int keySize;
    FreqNode* head;
    FreqNode* tail;
} AllOne;

FreqNode* createFreqNode(int count) {
    FreqNode* node = (FreqNode*)malloc(sizeof(FreqNode));
    node->count = count;
    node->keyCount = 0;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

AllOne* allOneCreate() {
    AllOne* obj = (AllOne*)malloc(sizeof(AllOne));
    obj->keySize = 0;
    obj->head = createFreqNode(0);
    obj->tail = createFreqNode(0);
    obj->head->next = obj->tail;
    obj->tail->prev = obj->head;
    return obj;
}

FreqNode* addNodeAfter(FreqNode* prevNode, int count) {
    FreqNode* newNode = createFreqNode(count);
    newNode->prev = prevNode;
    newNode->next = prevNode->next;
    prevNode->next->prev = newNode;
    prevNode->next = newNode;
    return newNode;
}

void removeNode(FreqNode* node) {
    node->prev->next = node->next;
    node->next->prev = node->prev;
    free(node);
}

int findKeyIndex(AllOne* obj, char* key) {
    for (int i = 0; i < obj->keySize; i++) {
        if (strcmp(obj->keyToFreq[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

void addKeyToNode(FreqNode* node, char* key) {
    strcpy(node->keys[node->keyCount], key);
    node->keyCount++;
}

void removeKeyFromNode(FreqNode* node, char* key) {
    for (int i = 0; i < node->keyCount; i++) {
        if (strcmp(node->keys[i], key) == 0) {
            for (int j = i; j < node->keyCount - 1; j++) {
                strcpy(node->keys[j], node->keys[j + 1]);
            }
            node->keyCount--;
            return;
        }
    }
}

void allOneInc(AllOne* obj, char* key) {
    int keyIndex = findKeyIndex(obj, key);
    
    if (keyIndex != -1) {
        FreqNode* node = obj->keyToNode[keyIndex];
        removeKeyFromNode(node, key);
        int nextCount = node->count + 1;
        
        FreqNode* nextNode;
        if (node->next->count != nextCount) {
            nextNode = addNodeAfter(node, nextCount);
        } else {
            nextNode = node->next;
        }
        
        addKeyToNode(nextNode, key);
        obj->keyToNode[keyIndex] = nextNode;
        
        if (node->keyCount == 0) {
            removeNode(node);
        }
    } else {
        FreqNode* firstNode;
        if (obj->head->next->count != 1) {
            firstNode = addNodeAfter(obj->head, 1);
        } else {
            firstNode = obj->head->next;
        }
        
        strcpy(obj->keyToFreq[obj->keySize], key);
        obj->keyToNode[obj->keySize] = firstNode;
        obj->keySize++;
        addKeyToNode(firstNode, key);
    }
}

void allOneDec(AllOne* obj, char* key) {
    int keyIndex = findKeyIndex(obj, key);
    FreqNode* node = obj->keyToNode[keyIndex];
    removeKeyFromNode(node, key);
    
    if (node->count == 1) {
        for (int i = keyIndex; i < obj->keySize - 1; i++) {
            strcpy(obj->keyToFreq[i], obj->keyToFreq[i + 1]);
            obj->keyToNode[i] = obj->keyToNode[i + 1];
        }
        obj->keySize--;
    } else {
        int prevCount = node->count - 1;
        FreqNode* prevNode;
        if (node->prev->count != prevCount) {
            prevNode = addNodeAfter(node->prev, prevCount);
        } else {
            prevNode = node->prev;
        }
        
        addKeyToNode(prevNode, key);
        obj->keyToNode[keyIndex] = prevNode;
    }
    
    if (node->keyCount == 0) {
        removeNode(node);
    }
}

char* allOneGetMaxKey(AllOne* obj) {
    if (obj->tail->prev == obj->head) return "";
    return obj->tail->prev->keys[0];
}

char* allOneGetMinKey(AllOne* obj) {
    if (obj->head->next == obj->tail) return "";
    return obj->head->next->keys[0];
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) key lookup, doubly-linked list provides O(1) insertion/deletion

✓ Linear Growth

Space Complexity

O(n)

Hash map stores n keys, linked list nodes store frequency levels (at most n nodes)

⚡ Linearithmic Space

67.6K Views

Medium-High Frequency

~35 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Hash Map + Doubly Linked List (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler