 # 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];
}

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

## more LeetCode posts Design HashSet solution using TypeScript Fizz Buzz solution using TypeScript Pascal's Triangle solution using TypeScript Symmetric Tree solution using TypeScript Same Tree solution using TypeScript Maximum Subarray solution using TypeScript