Implement Stack using Queues

Implement Stack using Queues - Problem

Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (push, top, pop, and empty).

Implement the MyStack class:

void push(int x) - Pushes element x to the top of the stack
int pop() - Removes the element on the top of the stack and returns it
int top() - Returns the element on the top of the stack
boolean empty() - Returns true if the stack is empty, false otherwise

Notes:

You must use only standard operations of a queue: push to back, peek/pop from front, size, and is empty operations
Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque as long as you use only a queue's standard operations

Input & Output

Example 1 — Basic Stack Operations

$ Input: operations = ["MyStack", "push", "push", "top", "pop", "empty"], values = [null, 1, 2, null, null, null]

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

💡 Note: Create stack, push 1, push 2, top returns 2 (last pushed), pop returns 2, stack not empty (contains 1)

Example 2 — Single Element

$ Input: operations = ["MyStack", "push", "pop", "empty"], values = [null, 5, null, null]

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

💡 Note: Create stack, push 5, pop returns 5, stack is now empty

Example 3 — Multiple Operations

$ Input: operations = ["MyStack", "push", "push", "push", "top", "pop", "top"], values = [null, 1, 2, 3, null, null, null]

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

💡 Note: Push 1,2,3; top shows 3 (most recent); pop removes 3; top now shows 2

Constraints

1 ≤ x ≤ 9
At most 100 calls will be made to push, pop, top, and empty
All the calls to pop and top are guaranteed to be valid

Visualization

Tap to expand

Asked in

B Bloomberg 15 M Microsoft 12 a Amazon 10 🍎 Apple 8

The key insight is using two queues to simulate LIFO behavior by either maintaining reverse order (push-heavy) or transferring elements during access (pop-heavy). Best approach depends on usage pattern: push-heavy for frequent pop/top, pop-heavy for frequent push. Time: O(n) per operation, Space: O(n)

Common Approaches

✓ Two Queue Approach (Pop Heavy)

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

Keep elements in natural order in the main queue. For pop/top operations, transfer all elements except the last one to the helper queue, then get the last element and swap queues.

Two Queue Approach (Push Heavy)

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

Keep the main queue in reverse order so that the front always contains the most recently added element. For each push, add the new element then rotate all existing elements.

Two Queue Approach (Pop Heavy) — Algorithm Steps

Push: Simply add element to back of main queue
Pop: Move all but last element to helper queue, pop last element, swap queues
Top: Similar to pop but don't remove the element

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Phase

Elements added in natural order to main queue

Pop Preparation

Transfer all but last element to helper queue

Pop Result

Get last element and swap queues

Code -

solution.c — C

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

typedef enum {
    JSON_NULL,
    JSON_BOOL,
    JSON_NUMBER,
    JSON_STRING,
    JSON_ARRAY,
    JSON_OBJECT
} JsonType;

typedef struct JsonValue {
    JsonType type;
    union {
        bool bool_val;
        double num_val;
        char* str_val;
        struct {
            struct JsonValue** items;
            int count;
        } array;
        struct {
            char** keys;
            struct JsonValue** values;
            int count;
        } object;
    } data;
} JsonValue;

bool solution(JsonValue* o1, JsonValue* o2) {
    // Early return checks
    if (!o1 && !o2) return true;
    if (!o1 || !o2) return false;
    if (o1->type != o2->type) return false;
    
    switch (o1->type) {
        case JSON_NULL:
            return true;
        case JSON_BOOL:
            return o1->data.bool_val == o2->data.bool_val;
        case JSON_NUMBER:
            return o1->data.num_val == o2->data.num_val;
        case JSON_STRING:
            return strcmp(o1->data.str_val, o2->data.str_val) == 0;
        case JSON_ARRAY:
            // Early size check
            if (o1->data.array.count != o2->data.array.count) return false;
            
            // Early termination on mismatch
            for (int i = 0; i < o1->data.array.count; i++) {
                if (!solution(o1->data.array.items[i], o2->data.array.items[i])) {
                    return false;
                }
            }
            return true;
        case JSON_OBJECT:
            // Early size check
            if (o1->data.object.count != o2->data.object.count) return false;
            
            // Early termination on mismatch
            for (int i = 0; i < o1->data.object.count; i++) {
                char* key = o1->data.object.keys[i];
                bool found = false;
                for (int j = 0; j < o2->data.object.count; j++) {
                    if (strcmp(key, o2->data.object.keys[j]) == 0) {
                        if (!solution(o1->data.object.values[i], o2->data.object.values[j])) {
                            return false;
                        }
                        found = true;
                        break;
                    }
                }
                if (!found) return false;
            }
            return true;
    }
    return false;
}

JsonValue* parseJson(const char* json, int* pos);

char* parseString(const char* json, int* pos) {
    (*pos)++; // skip opening quote
    int start = *pos;
    while (json[*pos] && json[*pos] != '"') (*pos)++;
    int len = *pos - start;
    char* result = malloc(len + 1);
    strncpy(result, json + start, len);
    result[len] = '\0';
    (*pos)++; // skip closing quote
    return result;
}

double parseNumber(const char* json, int* pos) {
    int start = *pos;
    if (json[*pos] == '-') (*pos)++;
    while (json[*pos] && isdigit(json[*pos])) (*pos)++;
    if (json[*pos] == '.') {
        (*pos)++;
        while (json[*pos] && isdigit(json[*pos])) (*pos)++;
    }
    char temp = json[*pos];
    ((char*)json)[*pos] = '\0';
    double result = atof(json + start);
    ((char*)json)[*pos] = temp;
    return result;
}

JsonValue* parseArray(const char* json, int* pos) {
    JsonValue* result = malloc(sizeof(JsonValue));
    result->type = JSON_ARRAY;
    result->data.array.items = NULL;
    result->data.array.count = 0;
    
    (*pos)++; // skip '['
    while (json[*pos] && isspace(json[*pos])) (*pos)++;
    
    if (json[*pos] == ']') {
        (*pos)++;
        return result;
    }
    
    int capacity = 4;
    result->data.array.items = malloc(capacity * sizeof(JsonValue*));
    
    while (true) {
        if (result->data.array.count >= capacity) {
            capacity *= 2;
            result->data.array.items = realloc(result->data.array.items, capacity * sizeof(JsonValue*));
        }
        result->data.array.items[result->data.array.count++] = parseJson(json, pos);
        
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
        if (json[*pos] == ']') break;
        if (json[*pos] == ',') (*pos)++;
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
    }
    (*pos)++; // skip ']'
    return result;
}

JsonValue* parseObject(const char* json, int* pos) {
    JsonValue* result = malloc(sizeof(JsonValue));
    result->type = JSON_OBJECT;
    result->data.object.keys = NULL;
    result->data.object.values = NULL;
    result->data.object.count = 0;
    
    (*pos)++; // skip '{'
    while (json[*pos] && isspace(json[*pos])) (*pos)++;
    
    if (json[*pos] == '}') {
        (*pos)++;
        return result;
    }
    
    int capacity = 4;
    result->data.object.keys = malloc(capacity * sizeof(char*));
    result->data.object.values = malloc(capacity * sizeof(JsonValue*));
    
    while (true) {
        if (result->data.object.count >= capacity) {
            capacity *= 2;
            result->data.object.keys = realloc(result->data.object.keys, capacity * sizeof(char*));
            result->data.object.values = realloc(result->data.object.values, capacity * sizeof(JsonValue*));
        }
        
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
        char* key = parseString(json, pos);
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
        (*pos)++; // skip ':'
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
        JsonValue* value = parseJson(json, pos);
        
        result->data.object.keys[result->data.object.count] = key;
        result->data.object.values[result->data.object.count] = value;
        result->data.object.count++;
        
        while (json[*pos] && isspace(json[*pos])) (*pos)++;
        if (json[*pos] == '}') break;
        if (json[*pos] == ',') (*pos)++;
    }
    (*pos)++; // skip '}'
    return result;
}

JsonValue* parseJson(const char* json, int* pos) {
    while (json[*pos] && isspace(json[*pos])) (*pos)++;
    
    JsonValue* result = malloc(sizeof(JsonValue));
    
    if (strncmp(json + *pos, "null", 4) == 0) {
        result->type = JSON_NULL;
        *pos += 4;
        return result;
    } else if (strncmp(json + *pos, "true", 4) == 0) {
        result->type = JSON_BOOL;
        result->data.bool_val = true;
        *pos += 4;
        return result;
    } else if (strncmp(json + *pos, "false", 5) == 0) {
        result->type = JSON_BOOL;
        result->data.bool_val = false;
        *pos += 5;
        return result;
    } else if (json[*pos] == '"') {
        result->type = JSON_STRING;
        result->data.str_val = parseString(json, pos);
        return result;
    } else if (json[*pos] == '[') {
        free(result);
        return parseArray(json, pos);
    } else if (json[*pos] == '{') {
        free(result);
        return parseObject(json, pos);
    } else {
        result->type = JSON_NUMBER;
        result->data.num_val = parseNumber(json, pos);
        return result;
    }
}

int main() {
    char o1[10000], o2[10000];
    fgets(o1, sizeof(o1), stdin);
    fgets(o2, sizeof(o2), stdin);
    
    o1[strcspn(o1, "\n")] = 0;
    o2[strcspn(o2, "\n")] = 0;
    
    int pos1 = 0, pos2 = 0;
    JsonValue* json1 = parseJson(o1, &pos1);
    JsonValue* json2 = parseJson(o2, &pos2);
    
    bool result = solution(json1, json2);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Pop and top require moving n-1 elements between queues, push is O(1)

✓ Linear Growth

Space Complexity

O(n)

Two queues store n elements total

⚡ Linearithmic Space

89.5K Views

Medium Frequency

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

Two Queue Approach (Pop Heavy) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler