Min Stack solution using TypeScript

This post outlines my TypeScript solution to the "Min Stack" question on LeetCode.

Algorithm: This solution uses a single stack. Each node on the stack contains two numbers: the value that was pushed, and the minimum value on the stack at the time of pushing the node onto the stack. This allows the class to provide a getMin method that runs in constant time.

Time Complexity: Because all methods of the stack class consist only of operations that run in constant time, the time complexity is O(1).

Space Complexity: Each method of the class uses a constant amount of space except for the push method, which stores the element on the stack. This makes the space complexity O(n) where n represents the number of elements pushed onto the stack.

/**
 * Min Stack
 * Design a stack that supports push, pop, 
 * top, and retrieving the minimum element 
 * in constant time.
 */
class MinStack {
    private stack: [number, number][] = []
    
    constructor() {}

    /**
     * Push element x onto stack.
     * Time Complexity: O(1);
     * Space Complexity: O(n);
     */
    push(x: number): void {
        const min = this.stack.length
            ? Math.min(this.getMin(), x)
            : x; // only number in stack
        this.stack.push([x, min]);
    }

    /**
     * Removes the element on top of the stack.
     * Time Complexity: O(1);
     * Space Complexity: O(1);
     */
    pop(): void {
        this.stack.pop();
    }

    /**
     * Get the top element.
     * Time Complexity: O(1);
     * Space Complexity: O(1);
     */
    top(): number {
        return this.stack[this.stack.length - 1][0];
    }

    /**
     * Retrieve the minimum element in the stack.
     * Time Complexity: O(1);
     * Space Complexity: O(1);
     */
    getMin(): number {
        return this.stack[this.stack.length - 1][1];
    }
}