Max Stack - Practice Coding Problems

Max Stack - Problem

Linked List Stack Design Doubly-Linked List Ordered Set Hard

Design a max stack data structure that combines the functionality of a traditional stack with efficient maximum element retrieval. Think of it as a smart stack that always knows its maximum element!

Your MaxStack class must support these operations:

push(x) - Add element x to the top of the stack
pop() - Remove and return the top element
top() - Get the top element without removing it
peekMax() - Find the maximum element without removing it
popMax() - Remove and return the maximum element (if multiple exist, remove the topmost one)

Performance Requirements: top() must run in O(1) time, while all other operations should run in O(log n) time.

Example: If your stack contains [5, 1, 5] (bottom to top), calling popMax() should remove the top 5 (not the bottom one) and return it.

Input & Output

example_1.py — Basic Operations

$ Input: ["MaxStack","push","push","push","top","popMax","top","peekMax","pop","top"] [[],[5],[1],[5],[],[],[],[],[],[]]

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

💡 Note: MaxStack stk = new MaxStack(); stk.push(5); stk.push(1); stk.push(5); stk.top(); // return 5; stk.popMax(); // return 5; stk.top(); // return 1; stk.peekMax(); // return 5; stk.pop(); // return 1; stk.top(); // return 5

example_2.py — Duplicate Maximums

$ Input: ["MaxStack","push","push","push","popMax","popMax","popMax"] [[],[3],[3],[3],[],[],[]]

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

💡 Note: When multiple maximum elements exist, popMax() removes the topmost one first. All three 3's are removed in LIFO order.

example_3.py — Mixed Operations

$ Input: ["MaxStack","push","push","peekMax","push","peekMax","popMax","top"] [[],[1],[2],[],[3],[],[],[]]

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

💡 Note: Stack evolution: [1] → [1,2] → peek 2 → [1,2,3] → peek 3 → popMax removes 3 → [1,2] → top is 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

Understanding the Visualization

Order Arrives

New order goes on top of the spike AND gets logged in the priority ledger

Regular Service

Normal orders are taken from the top of the spike (LIFO)

Priority Service

When a VIP order needs to be served, quickly locate it using the ledger and remove it from the spike

Efficient Tracking

The dual system ensures both stack operations and priority lookups are fast

Key Takeaway

🎯 Key Insight: By maintaining elements in both a doubly-linked list (for stack order) and a TreeMap (for value priority), we achieve O(1) top operations and O(log n) max operations - the perfect balance of efficiency!

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 24 Apple 19

The optimal solution uses a doubly-linked list for O(1) stack operations combined with a TreeMap for O(log n) maximum element tracking. Each element exists as a node in both structures simultaneously, allowing efficient removal from any position while maintaining stack semantics.

Common Approaches

Approach	Time	Space	Notes
✓ Doubly-Linked List + TreeMap (Optimal)	O(log n)	O(n)	Combine doubly-linked list for stack ops with balanced tree for O(log n) max operations
Two Stacks Approach	O(n)	O(n)	Use main stack plus auxiliary max stack to track maximums

Doubly-Linked List + TreeMap (Optimal) — Algorithm Steps

Use doubly-linked list for stack operations (push/pop/top)
Use TreeMap mapping values to lists of nodes for max tracking
For push: add node to list tail and TreeMap
For popMax: find max in TreeMap, remove topmost occurrence from list

Visualization

Tap to expand

Step-by-Step Walkthrough

Dual Structure

Each element exists as a node in doubly-linked list AND in TreeMap

O(1) Top Operations

Direct access to tail of linked list

O(log n) Max Operations

TreeMap provides efficient max lookup and removal

Code -

solution.c — C

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

#define MAX_VALS 1000
#define MAX_NODES_PER_VAL 100

typedef struct Node {
    int val;
    struct Node* prev;
    struct Node* next;
} Node;

typedef struct {
    Node* nodes[MAX_NODES_PER_VAL];
    int count;
} NodeList;

typedef struct {
    Node* head;
    Node* tail;
    NodeList valueMaps[MAX_VALS + 500]; // Offset for negative values
} MaxStack;

int getIndex(int val) {
    return val + 500; // Offset to handle negative values
}

MaxStack* maxStackCreate() {
    MaxStack* ms = malloc(sizeof(MaxStack));
    ms->head = malloc(sizeof(Node));
    ms->tail = malloc(sizeof(Node));
    ms->head->val = 0;
    ms->tail->val = 0;
    ms->head->next = ms->tail;
    ms->tail->prev = ms->head;
    ms->head->prev = NULL;
    ms->tail->next = NULL;
    
    for (int i = 0; i < MAX_VALS + 500; i++) {
        ms->valueMaps[i].count = 0;
    }
    
    return ms;
}

void maxStackPush(MaxStack* obj, int x) {
    Node* node = malloc(sizeof(Node));
    node->val = x;
    
    // Add to end of linked list
    Node* prevNode = obj->tail->prev;
    prevNode->next = node;
    node->prev = prevNode;
    node->next = obj->tail;
    obj->tail->prev = node;
    
    // Add to value map
    int idx = getIndex(x);
    NodeList* list = &obj->valueMaps[idx];
    list->nodes[list->count++] = node;
}

int maxStackPop(MaxStack* obj) {
    Node* node = obj->tail->prev;
    int val = node->val;
    
    // Remove from linked list
    node->prev->next = node->next;
    node->next->prev = node->prev;
    
    // Remove from value map
    int idx = getIndex(val);
    NodeList* list = &obj->valueMaps[idx];
    for (int i = 0; i < list->count; i++) {
        if (list->nodes[i] == node) {
            for (int j = i; j < list->count - 1; j++) {
                list->nodes[j] = list->nodes[j + 1];
            }
            list->count--;
            break;
        }
    }
    
    free(node);
    return val;
}

int maxStackTop(MaxStack* obj) {
    return obj->tail->prev->val;
}

int maxStackPeekMax(MaxStack* obj) {
    int maxVal = INT_MIN;
    for (int i = 0; i < MAX_VALS + 500; i++) {
        if (obj->valueMaps[i].count > 0) {
            int val = i - 500;
            if (val > maxVal) {
                maxVal = val;
            }
        }
    }
    return maxVal;
}

int maxStackPopMax(MaxStack* obj) {
    int maxVal = maxStackPeekMax(obj);
    int idx = getIndex(maxVal);
    NodeList* list = &obj->valueMaps[idx];
    Node* node = list->nodes[list->count - 1];
    
    // Remove from linked list
    node->prev->next = node->next;
    node->next->prev = node->prev;
    
    // Remove from value map
    list->count--;
    
    free(node);
    return maxVal;
}

void maxStackFree(MaxStack* obj) {
    Node* curr = obj->head;
    while (curr) {
        Node* next = curr->next;
        free(curr);
        curr = next;
    }
    free(obj);
}

int main() {
    MaxStack* stack = maxStackCreate();
    maxStackPush(stack, 5);
    maxStackPush(stack, 1);
    maxStackPush(stack, 5);
    printf("%d\n", maxStackPeekMax(stack)); // 5
    printf("%d\n", maxStackPopMax(stack)); // 5
    printf("%d\n", maxStackTop(stack)); // 1
    maxStackFree(stack);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

O(1) for top, O(log n) for push/pop/peekMax/popMax due to TreeMap operations

⚡ Linearithmic

Space Complexity

O(n)

Doubly-linked list nodes plus TreeMap entries, each element stored in both structures

⚡ Linearithmic Space

71.3K Views

High Frequency

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

Doubly-Linked List + TreeMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler