Max Stack

Max Stack - Problem

Linked List Stack Design Doubly-Linked List Ordered Set Hard

Design a max stack data structure that supports the stack operations and supports finding the stack's maximum element.

Implement the MaxStack class:

MaxStack() Initializes the stack object.
void push(int x) Pushes element x onto the stack.
int pop() Removes the element on top of the stack and returns it.
int top() Gets the element on the top of the stack without removing it.
int peekMax() Retrieves the maximum element in the stack without removing it.
int popMax() Retrieves the maximum element in the stack and removes it. If there is more than one maximum element, only remove the top-most one.

You must come up with a solution that supports O(1) for each top call and O(log n) for each other call.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["MaxStack","push","push","top","popMax","top"], values = [[],[5],[1],[],[],[]]

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

💡 Note: MaxStack() creates empty stack. push(5) adds 5. push(1) adds 1 on top. top() returns 1 (top element). popMax() removes and returns 5 (maximum). top() returns 1 (now the only element).

Example 2 — Multiple Max Elements

$ Input: operations = ["MaxStack","push","push","push","peekMax","popMax","top"], values = [[],[5],[1],[5],[],[],[]]

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

💡 Note: After pushing 5,1,5: stack is [5,1,5]. peekMax() returns 5. popMax() removes the top-most 5, leaving [5,1]. top() returns 1.

Example 3 — Pop vs PopMax

$ Input: operations = ["MaxStack","push","push","push","pop","popMax"], values = [[],[3],[2],[1],[],[]]

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

💡 Note: Stack becomes [3,2,1]. pop() removes top element 1, leaving [3,2]. popMax() removes maximum 3, leaving [2].

Constraints

-10⁷ ≤ x ≤ 10⁷
At most 10⁵ calls will be made to push, pop, top, peekMax, and popMax.
There will be at least one element in the stack when pop, top, peekMax, or popMax is called.

Visualization

Tap to expand

Asked in

G Google 45 A Amazon 38 F Facebook 32 M Microsoft 28

The key insight is to combine a doubly-linked list for stack operations with an ordered data structure (TreeMap/OrderedDict) for efficient max operations. The doubly-linked list provides O(1) access to the top element, while the ordered structure enables O(log n) max operations. Best approach uses Doubly-Linked List + TreeMap. Time: O(1) for top, O(log n) for others, Space: O(n)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Array with Linear Search

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

Store elements in an array and maintain stack operations. For max operations, search through the entire array to find maximum element.

Doubly Linked List + Ordered Set

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

Maintain elements in a doubly-linked list for stack operations and use an ordered set to track elements by value for efficient max operations. Each node has pointers to maintain both structures.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    double improvement;
    int index;
    int passCount;
    int totalCount;
} ClassInfo;

typedef struct {
    ClassInfo* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(ClassInfo));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(ClassInfo* a, ClassInfo* b) {
    ClassInfo temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MaxHeap* heap, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    if (heap->data[parent].improvement < heap->data[idx].improvement) {
        swap(&heap->data[parent], &heap->data[idx]);
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MaxHeap* heap, int idx) {
    int largest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    
    if (left < heap->size && heap->data[left].improvement > heap->data[largest].improvement)
        largest = left;
    if (right < heap->size && heap->data[right].improvement > heap->data[largest].improvement)
        largest = right;
    
    if (largest != idx) {
        swap(&heap->data[idx], &heap->data[largest]);
        heapifyDown(heap, largest);
    }
}

void push(MaxHeap* heap, ClassInfo info) {
    heap->data[heap->size] = info;
    heapifyUp(heap, heap->size);
    heap->size++;
}

ClassInfo pop(MaxHeap* heap) {
    ClassInfo result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return result;
}

double calculateImprovement(int passCount, int totalCount) {
    // Improvement = (total-pass) / (total*(total+1))
    return (double)(totalCount - passCount) / (totalCount * (totalCount + 1));
}

double solution(int classes[][2], int n, int extraStudents) {
    MaxHeap* heap = createHeap(n + extraStudents);
    
    // Initialize heap
    for (int i = 0; i < n; i++) {
        double improve = calculateImprovement(classes[i][0], classes[i][1]);
        ClassInfo info = {improve, i, classes[i][0], classes[i][1]};
        push(heap, info);
    }
    
    // Assign extra students
    for (int j = 0; j < extraStudents; j++) {
        ClassInfo best = pop(heap);
        
        int newPass = best.passCount + 1;
        int newTotal = best.totalCount + 1;
        classes[best.index][0] = newPass;
        classes[best.index][1] = newTotal;
        
        double newImprove = calculateImprovement(newPass, newTotal);
        ClassInfo newInfo = {newImprove, best.index, newPass, newTotal};
        push(heap, newInfo);
    }
    
    // Calculate final average
    double totalRatio = 0;
    for (int i = 0; i < n; i++) {
        totalRatio += (double) classes[i][0] / classes[i][1];
    }
    
    free(heap->data);
    free(heap);
    
    return totalRatio / n;
}

int parseClasses(char* line, int classes[][2]) {
    int n = 0;
    char* ptr = line + 1; // skip '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            classes[n][0] = strtol(ptr, &ptr, 10);
            ptr++; // skip ','
            classes[n][1] = strtol(ptr, &ptr, 10);
            n++;
            ptr++; // skip ']'
        }
        if (*ptr == ',') ptr++;
    }
    return n;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int classes[100][2];
    int n = parseClasses(line, classes);
    
    int extraStudents;
    scanf("%d", &extraStudents);
    
    double result = solution(classes, n, extraStudents);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~35 min Avg. Time

1.9K 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