feat(azl397985856#155): 增加辅助栈的解法

Author: azl397985856

problems/155.min-stack.md

@@ -1,8 +1,8 @@
-## 题目地址
+# 题目地址
 
 https://leetcode.com/problems/min-stack/description/
 
-## 题目描述
+# 题目描述
 
 ```
 Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
@@ -23,12 +23,14 @@ minStack.getMin();   --> Returns -2.
 
 ```
 
+# 差值法
+
 ## 思路
 
 符合直觉的方法是，每次对栈进行修改操作（push和pop）的时候更新最小值。 然后getMin只需要返回我们计算的最小值即可，
 top也是直接返回栈顶元素即可。  这种做法每次修改栈都需要更新最小值，因此时间复杂度是O(n).
 
-![](https://tva1.sinaimg.cn/large/0082zybply1gburknpsi5j30d609g3z0.jpg)
+![](https://pic.leetcode-cn.com/7beed41b8dc0325445721a36b7db34e1af902441b67996d2eeadcb1f5a5e33d9.jpg)
 
 是否有更高效的算法呢？答案是有的。
 
@@ -50,8 +52,8 @@ pop或者top的时候：
 
 - 如果栈顶元素大于0，说明它对最小值`没有影响`，上一个最小值就是上上个最小值。
 
-![](https://tva1.sinaimg.cn/large/0082zybply1gburkz4jwjj30ji0k1jtm.jpg)
-![](https://tva1.sinaimg.cn/large/0082zybply1gburlamkrcj30ht0b4jsh.jpg)
+![](https://pic.leetcode-cn.com/7da0473d92d70bb47ce7b62303c062e5f517b09d1bf501c4ad341b65415d5c43.jpg)
+![](https://pic.leetcode-cn.com/aefec54238c942c484837ea6c724304fb179d3d64f110481d955d9eea65c4fc5.jpg)
 
 ## 关键点
 
@@ -75,7 +77,7 @@ Javascript Code:
  */
 var MinStack = function() {
   this.stack = [];
-  this.min = Number.MAX_VALUE;
+  this.minV = Number.MAX_VALUE;
 };
 
 /**
@@ -84,45 +86,45 @@ var MinStack = function() {
  */
 MinStack.prototype.push = function(x) {
   // update 'min'
-  const min = this.min;
-  if (x < this.min) {
-    this.min = x;
+  const minV = this.minV;
+  if (x < this.minV) {
+    this.minV = x;
   }
-  return this.stack.push(x - min);
+  return this.stack.push(x - minV);
 };
 
 /**
  * @return {void}
  */
 MinStack.prototype.pop = function() {
   const item = this.stack.pop();
-  const min = this.min;
+  const minV = this.minV;
 
   if (item < 0) {
-    this.min = min - item;
-    return min;
+    this.minV = minV - item;
+    return minV;
   }
-  return item + min;
+  return item + minV;
 };
 
 /**
  * @return {number}
  */
 MinStack.prototype.top = function() {
   const item = this.stack[this.stack.length - 1];
-  const min = this.min;
+  const minV = this.minV;
 
   if (item < 0) {
-    return min;
+    return minV;
   }
-  return item + min;
+  return item + minV;
 };
 
 /**
  * @return {number}
  */
-MinStack.prototype.getMin = function() {
-  return this.min;
+MinStack.prototype.min = function() {
+  return this.minV;
 };
 
 /**
@@ -131,7 +133,7 @@ MinStack.prototype.getMin = function() {
  * obj.push(x)
  * obj.pop()
  * var param_3 = obj.top()
- * var param_4 = obj.getMin()
+ * var param_4 = obj.min()
  */
 ```
 
@@ -144,32 +146,32 @@ class MinStack:
         """
         initialize your data structure here.
         """
-        self.min = float('inf')
+        self.minV = float('inf')
         self.stack = []
 
     def push(self, x: int) -> None:
-        self.stack.append(x - self.min)
-        if x < self.min:
-            self.min = x
+        self.stack.append(x - self.minV)
+        if x < self.minV:
+            self.minV = x
 
     def pop(self) -> None:
         if not self.stack:
             return
         tmp = self.stack.pop()
         if tmp < 0:
-            self.min -= tmp
+            self.minV -= tmp
 
     def top(self) -> int:
         if not self.stack:
             return
         tmp = self.stack[-1]
         if tmp < 0:
-            return self.min
+            return self.minV
         else:
-            return self.min + tmp
+            return self.minV + tmp
 
-    def getMin(self) -> int:
-        return self.min
+    def min(self) -> int:
+        return self.minV
 
 
 
@@ -178,5 +180,125 @@ class MinStack:
 # obj.push(x)
 # obj.pop()
 # param_3 = obj.top()
-# param_4 = obj.getMin()
+# param_4 = obj.min()
 ```
+
+**复杂度分析**
+- 时间复杂度：O(1)
+- 空间复杂度：O(1)
+
+
+# 两个栈
+
+## 思路
+
+我们使用两个栈：
+
+- 一个栈存放全部的元素，push，pop都是正常操作这个正常栈。
+- 另一个存放最小栈。 每次push，如果比最小栈的栈顶还小，我们就push进最小栈，否则不操作
+- 每次pop的时候，我们都判断其是否和最小栈栈顶元素相同，如果相同，那么我们pop掉最小栈的栈顶元素即可
+
+## 关键点
+
+- 往minstack中 push的判断条件。 应该是stack为空或者x小于等于minstack栈顶元素
+
+
+## 代码
+
+JavaScript：
+
+```js
+/**
+ * initialize your data structure here.
+ */
+var MinStack = function() {
+    this.stack = []
+    this.minStack = []
+};
+
+/** 
+ * @param {number} x
+ * @return {void}
+ */
+MinStack.prototype.push = function(x) {
+    this.stack.push(x)
+    if (this.minStack.length == 0 ||  x <= this.minStack[this.minStack.length - 1]) {
+        this.minStack.push(x)
+    }
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function() {
+    const x = this.stack.pop()
+    if (x !== void 0 &&  x === this.minStack[this.minStack.length - 1]) {
+        this.minStack.pop()
+    }
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function() {
+    return this.stack[this.stack.length - 1]
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.min = function() {
+    return this.minStack[this.minStack.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.min()
+ */
+```
+
+
+Python3:
+
+```python
+class MinStack:
+
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.stack = []
+        self.minstack = []
+
+    def push(self, x: int) -> None:
+        self.stack.append(x)
+        if not self.minstack or x <= self.minstack[-1]:
+            self.minstack.append(x)
+
+    def pop(self) -> None:
+        tmp = self.stack.pop()
+        if tmp == self.minstack[-1]:
+            self.minstack.pop()
+
+    def top(self) -> int:
+        return self.stack[-1]
+
+    def min(self) -> int:
+        return self.minstack[-1]
+
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(x)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.min()
+```
+
+**复杂度分析**
+- 时间复杂度：O(1)
+- 空间复杂度：O(N)