feat: add solutions to lc problem: No.0155

No.0155.Min Stack

Author: yanglbme

solution/0100-0199/0155.Min Stack/README.md

@@ -64,7 +64,7 @@ minStack.getMin();   --> 返回 -2.
 -   当我们要获取当前栈中的栈顶元素时，我们只需要返回 `stk1` 的栈顶元素即可。
 -   当我们要获取当前栈中的最小值时，我们只需要返回 `stk2` 的栈顶元素即可。
 
-每个操作的时间复杂度为 $O(1)$。整体的空间复杂度为 $O(n)$。
+每个操作的时间复杂度为 $O(1)$。整体的空间复杂度为 $O(n)$，其中 $n$ 为栈中元素的个数。
 
 <!-- tabs:start -->
 
@@ -79,9 +79,9 @@ class MinStack:
         self.stk1 = []
         self.stk2 = [inf]
 
-    def push(self, x: int) -> None:
-        self.stk1.append(x)
-        self.stk2.append(min(x, self.stk2[-1]))
+    def push(self, val: int) -> None:
+        self.stk1.append(val)
+        self.stk2.append(min(val, self.stk2[-1]))
 
     def pop(self) -> None:
         self.stk1.pop()
@@ -96,7 +96,7 @@ class MinStack:
 
 # Your MinStack object will be instantiated and called as such:
 # obj = MinStack()
-# obj.push(x)
+# obj.push(val)
 # obj.pop()
 # param_3 = obj.top()
 # param_4 = obj.getMin()
@@ -111,14 +111,13 @@ class MinStack {
     private Deque<Integer> stk1 = new ArrayDeque<>();
     private Deque<Integer> stk2 = new ArrayDeque<>();
 
-    /** initialize your data structure here. */
     public MinStack() {
         stk2.push(Integer.MAX_VALUE);
     }
 
-    public void push(int x) {
-        stk1.push(x);
-        stk2.push(Math.min(x, stk2.peek()));
+    public void push(int val) {
+        stk1.push(val);
+        stk2.push(Math.min(val, stk2.peek()));
     }
 
     public void pop() {
@@ -138,7 +137,7 @@ class MinStack {
 /**
  * Your MinStack object will be instantiated and called as such:
  * MinStack obj = new MinStack();
- * obj.push(x);
+ * obj.push(val);
  * obj.pop();
  * int param_3 = obj.top();
  * int param_4 = obj.getMin();
@@ -150,14 +149,13 @@ class MinStack {
 ```cpp
 class MinStack {
 public:
-    /** initialize your data structure here. */
     MinStack() {
         stk2.push(INT_MAX);
     }
 
-    void push(int x) {
-        stk1.push(x);
-        stk2.push(min(x, stk2.top()));
+    void push(int val) {
+        stk1.push(val);
+        stk2.push(min(val, stk2.top()));
     }
 
     void pop() {
@@ -181,55 +179,13 @@ private:
 /**
  * Your MinStack object will be instantiated and called as such:
  * MinStack* obj = new MinStack();
- * obj->push(x);
+ * obj->push(val);
  * obj->pop();
  * int param_3 = obj->top();
  * int param_4 = obj->getMin();
  */
 ```
 
-### **TypeScript**
-
-```ts
-class MinStack {
-    stack: number[];
-    mins: number[];
-    constructor() {
-        this.stack = [];
-        this.mins = [];
-    }
-
-    push(x: number): void {
-        this.stack.push(x);
-        this.mins.push(Math.min(this.getMin(), x));
-    }
-
-    pop(): void {
-        this.stack.pop();
-        this.mins.pop();
-    }
-
-    top(): number {
-        return this.stack[this.stack.length - 1];
-    }
-
-    getMin(): number {
-        return this.mins.length == 0
-            ? Infinity
-            : this.mins[this.mins.length - 1];
-    }
-}
-
-/**
- * Your MinStack object will be instantiated and called as such:
- * var obj = new MinStack()
- * obj.push(x)
- * obj.pop()
- * var param_3 = obj.top()
- * var param_4 = obj.getMin()
- */
-```
-
 ### **Go**
 
 ```go
@@ -238,14 +194,13 @@ type MinStack struct {
 	stk2 []int
 }
 
-/** initialize your data structure here. */
 func Constructor() MinStack {
 	return MinStack{[]int{}, []int{math.MaxInt32}}
 }
 
-func (this *MinStack) Push(x int) {
-	this.stk1 = append(this.stk1, x)
-	this.stk2 = append(this.stk2, min(x, this.stk2[len(this.stk2)-1]))
+func (this *MinStack) Push(val int) {
+	this.stk1 = append(this.stk1, val)
+	this.stk2 = append(this.stk2, min(val, this.stk2[len(this.stk2)-1]))
 }
 
 func (this *MinStack) Pop() {
@@ -271,20 +226,110 @@ func min(a, b int) int {
 /**
  * Your MinStack object will be instantiated and called as such:
  * obj := Constructor();
- * obj.Push(x);
+ * obj.Push(val);
  * obj.Pop();
  * param_3 := obj.Top();
  * param_4 := obj.GetMin();
  */
 ```
 
+### **TypeScript**
+
+```ts
+class MinStack {
+    stk1: number[];
+    stk2: number[];
+
+    constructor() {
+        this.stk1 = [];
+        this.stk2 = [Infinity];
+    }
+
+    push(val: number): void {
+        this.stk1.push(val);
+        this.stk2.push(Math.min(val, this.stk2[this.stk2.length - 1]));
+    }
+
+    pop(): void {
+        this.stk1.pop();
+        this.stk2.pop();
+    }
+
+    top(): number {
+        return this.stk1[this.stk1.length - 1];
+    }
+
+    getMin(): number {
+        return this.stk2[this.stk2.length - 1];
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(x)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+```
+
+### **JavaScript**
+
+```js
+var MinStack = function () {
+    this.stk1 = [];
+    this.stk2 = [Infinity];
+};
+
+/**
+ * @param {number} val
+ * @return {void}
+ */
+MinStack.prototype.push = function (val) {
+    this.stk1.push(val);
+    this.stk2.push(Math.min(this.stk2[this.stk2.length - 1], val));
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function () {
+    this.stk1.pop();
+    this.stk2.pop();
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function () {
+    return this.stk1[this.stk1.length - 1];
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function () {
+    return this.stk2[this.stk2.length - 1];
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(val)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+```
+
 ### **Rust**
 
 ```rust
 use std::collections::VecDeque;
 struct MinStack {
-    stack: VecDeque<i32>,
-    min_stack: VecDeque<i32>,
+    stk1: VecDeque<i32>,
+    stk2: VecDeque<i32>,
 }
 
 
@@ -294,31 +339,30 @@ struct MinStack {
  */
 impl MinStack {
 
-    /** initialize your data structure here. */
     fn new() -> Self {
-        Self { stack: VecDeque::new(), min_stack: VecDeque::new() }
+        Self { stk1: VecDeque::new(), stk2: VecDeque::new() }
     }
 
     fn push(&mut self, x: i32) {
-        self.stack.push_back(x);
-        if self.min_stack.is_empty() || *self.min_stack.back().unwrap() >= x {
-            self.min_stack.push_back(x);
+        self.stk1.push_back(x);
+        if self.stk2.is_empty() || *self.stk2.back().unwrap() >= x {
+            self.stk2.push_back(x);
         }
     }
 
     fn pop(&mut self) {
-        let val = self.stack.pop_back().unwrap();
-        if *self.min_stack.back().unwrap() == val {
-            self.min_stack.pop_back();
+        let val = self.stk1.pop_back().unwrap();
+        if *self.stk2.back().unwrap() == val {
+            self.stk2.pop_back();
         }
     }
 
     fn top(&self) -> i32 {
-        *self.stack.back().unwrap()
+        *self.stk1.back().unwrap()
     }
 
     fn get_min(&self) -> i32 {
-        *self.min_stack.back().unwrap()
+        *self.stk2.back().unwrap()
     }
 }
 
@@ -338,26 +382,25 @@ impl MinStack {
 public class MinStack {
     private Stack<int> stk1 = new Stack<int>();
     private Stack<int> stk2 = new Stack<int>();
-
-    /** initialize your data structure here. */
+    
     public MinStack() {
         stk2.Push(int.MaxValue);
     }
-
+    
     public void Push(int x) {
         stk1.Push(x);
         stk2.Push(Math.Min(x, GetMin()));
     }
-
+    
     public void Pop() {
         stk1.Pop();
         stk2.Pop();
     }
-
+    
     public int Top() {
         return stk1.Peek();
     }
-
+    
     public int GetMin() {
         return stk2.Peek();
     }