Maximum Frequency Stack - Practice Coding Problems

Maximum Frequency Stack - Problem

Design a Frequency Stack that efficiently handles push and pop operations based on element frequency.

You need to implement a special stack-like data structure called FreqStack with the following operations:

FreqStack(): Initialize an empty frequency stack
push(int val): Add an integer to the stack
pop(): Remove and return the most frequent element

The key challenge is handling tie-breaking: when multiple elements have the same highest frequency, return the one that was pushed most recently among those tied elements.

Example:
FreqStack freqStack = new FreqStack();
freqStack.push(5); // stack: [5]
freqStack.push(7); // stack: [5,7]
freqStack.push(5); // stack: [5,7,5]
freqStack.pop(); // returns 5 (frequency 2, most recent)
freqStack.pop(); // returns 7 (frequency 1)

Input & Output

example_1.py — Basic Operations

$ Input: ["FreqStack", "push", "push", "push", "push", "pop", "pop", "pop", "pop"] [[], [5], [7], [5], [4], [], [], [], []]

› Output: [null, null, null, null, null, 5, 7, 5, 4]

💡 Note: After pushing 5,7,5,4: frequencies are 5→2, 7→1, 4→1. Pop returns 5 (freq 2, most recent), then 7 (freq 1), then 5 (freq 1), then 4 (freq 1).

example_2.py — Frequency Ties

$ Input: ["FreqStack", "push", "push", "push", "pop", "pop", "pop"] [[], [1], [2], [1], [], [], []]

› Output: [null, null, null, null, 1, 2, 1]

💡 Note: After pushing 1,2,1: frequency of 1 is 2, frequency of 2 is 1. Pop returns most recent 1, then 2, then remaining 1.

example_3.py — Single Element

$ Input: ["FreqStack", "push", "push", "push", "pop", "pop", "pop"] [[], [3], [3], [3], [], [], []]

› Output: [null, null, null, null, 3, 3, 3]

💡 Note: Pushing the same element three times creates frequencies 1, 2, 3. Popping returns them in reverse order of push (LIFO within same element).

Constraints

1 ≤ val ≤ 10⁹
At most 2 * 10⁴ calls will be made to push and pop
pop is guaranteed to be called on a non-empty stack

Visualization

Tap to expand

Understanding the Visualization

Customer Arrives

When a customer enters, we check their visit history and increment their frequency count

Assign VIP Level

Based on frequency, we assign them to the appropriate VIP section (frequency stack)

Seating Order

Within each VIP level, customers are seated in order of arrival (stack structure)

Service Priority

When serving, we always serve from the highest VIP level, taking the most recent customer from that level

Key Takeaway

🎯 Key Insight: By grouping elements into frequency-based stacks, we achieve O(1) operations while naturally handling both frequency priority and recency tie-breaking through the stack's LIFO property.

Asked in

G Google 15 a Amazon 12 f Meta 8 Apple 6

The optimal solution uses two hash maps: one to track element frequencies and another to group elements into frequency-based stacks. This achieves O(1) time complexity for both push and pop operations while correctly handling tie-breaking by maintaining insertion order within each frequency level.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n²)	O(n)	Store all elements and search for maximum frequency on each pop
Optimal Hash Table + Stack Groups	O(1)	O(n)	Use frequency counter and stack groups for each frequency level

Brute Force (Linear Search) — Algorithm Steps

Store all pushed elements in a list
On pop, scan entire list to count frequencies
Find element with max frequency that appeared most recently
Remove and return that element

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Elements

Add elements to a simple array

Count Frequencies

Scan entire array to count each element's frequency

Find Maximum

Determine which frequency is highest

Find Most Recent

Scan from end to find most recent element with max frequency

Code -

solution.c — C

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

#define MAX_SIZE 10000

typedef struct {
    int stack[MAX_SIZE];
    int size;
} FreqStack;

FreqStack* freqStackCreate() {
    FreqStack* fs = (FreqStack*)malloc(sizeof(FreqStack));
    fs->size = 0;
    return fs;
}

void freqStackPush(FreqStack* obj, int val) {
    if (obj->size < MAX_SIZE) {
        obj->stack[obj->size++] = val;
    }
}

int freqStackPop(FreqStack* obj) {
    if (obj->size == 0) return -1;
    
    int freqCount[MAX_SIZE] = {0};
    int present[MAX_SIZE] = {0};
    
    // Count frequencies (assuming values are small positive integers)
    for (int i = 0; i < obj->size; i++) {
        if (obj->stack[i] < MAX_SIZE) {
            freqCount[obj->stack[i]]++;
            present[obj->stack[i]] = 1;
        }
    }
    
    // Find max frequency
    int maxFreq = 0;
    for (int i = 0; i < MAX_SIZE; i++) {
        if (present[i] && freqCount[i] > maxFreq) {
            maxFreq = freqCount[i];
        }
    }
    
    // Find most recent element with max frequency
    for (int i = obj->size - 1; i >= 0; i--) {
        if (obj->stack[i] < MAX_SIZE && freqCount[obj->stack[i]] == maxFreq) {
            int result = obj->stack[i];
            // Shift elements
            for (int j = i; j < obj->size - 1; j++) {
                obj->stack[j] = obj->stack[j + 1];
            }
            obj->size--;
            return result;
        }
    }
    
    return -1;
}

void freqStackFree(FreqStack* obj) {
    free(obj);
}

int main() {
    FreqStack* freqStack = freqStackCreate();
    freqStackPush(freqStack, 5);
    freqStackPush(freqStack, 7);
    freqStackPush(freqStack, 5);
    printf("%d\n", freqStackPop(freqStack)); // 5
    printf("%d\n", freqStackPop(freqStack)); // 7
    freqStackFree(freqStack);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each pop operation scans all n elements, and we might do n pops

⚠ Quadratic Growth

Space Complexity

O(n)

Store all elements in a single list

⚡ Linearithmic Space

89.5K Views

Medium-High Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler