🎨 update: stack and queue

Author: ConardLi

docs/.vuepress/config.js

@@ -77,6 +77,15 @@ module.exports = {
                         '/dataStructure/堆/最小的k个数',
                     ]
                 },
+                {
+                    title: '栈和队列',
+                    children: [
+                        '/dataStructure/栈和队列/包含min函数的栈',
+                        '/dataStructure/栈和队列/滑动窗口的最大值',
+                        '/dataStructure/栈和队列/用两个栈实现队列',
+                        '/dataStructure/栈和队列/栈的压入弹出序列',
+                    ]
+                },
             ]
         }
     }

docs/dataStructure/栈和队列/包含min函数的栈.md

@@ -0,0 +1,56 @@
+---
+{
+  "title": "包含min函数的栈",
+}
+---
+
+## 包含min函数的栈
+
+定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
+
+## 思路 
+
+1.定义两个栈，一个栈用于存储数据，另一个栈用于存储每次数据进栈时栈的最小值.
+
+2.每次数据进栈时，将此数据和最小值栈的栈顶元素比较，将二者比较的较小值再次存入最小值栈.
+
+4.数据栈出栈，最小值栈也出栈。
+
+3.这样最小值栈的栈顶永远是当前栈的最小值。
+
+以数据[3,4,2,7,9,0]为例，让这组数字依次如栈，则栈和其对应的最小值栈如下：
+
+![](../../dist/img/mainstack.png)
+
+## 代码
+
+```js
+var dataStack = [];
+var minStack = [];
+ 
+function push(node)
+{
+    dataStack.push(node);
+    if(minStack.length === 0 ||  node < min()){
+        minStack.push(node);
+    }else{
+        minStack.push(min());
+    }
+}
+function pop()
+{
+    minStack.pop();
+    return dataStack.pop();
+}
+function top()
+{
+    var length = dataStack.length;
+    return length>0&&dataStack[length-1]
+}
+function min()
+{
+    var length = minStack.length;
+    return length>0&&minStack[length-1]
+}
+```
+

docs/dataStructure/栈和队列/栈的压入弹出序列.md

@@ -0,0 +1,47 @@
+---
+{
+  "title": "栈的压入弹出序列",
+}
+---
+
+
+## 栈的压入、弹出序列
+输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列`1,2,3,4,5`是某栈的压入顺序，序列`4,5,3,2,1`是该压栈序列对应的一个弹出序列，但`4,3,5,1,2`就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
+
+## 思路
+
+1.借助一个辅助栈来模拟压入、弹出的过程。
+
+2.设置一个索引`idx`，记录`popV`（出栈序列）栈顶的位置
+
+3.将`pushV`（压入顺序）中的数据依次入栈。
+
+4.当辅助栈栈顶元素和压`popV`栈顶元素相同时，辅助栈出栈。每次出栈索引`idx`+1。
+
+5.出栈有可能在任意一次入栈后进行，当辅助栈栈顶元素和压`popV`栈顶元素相同时，继续让`pushV`入辅助栈。
+
+6.当所有数据入栈完成，如果出栈顺序正确，那么辅助栈应该为空。
+
+
+![](../../dist/img/栈的压入弹出序列.png)
+
+## 代码
+
+```js
+    function IsPopOrder(pushV, popV) {
+      if (!pushV || !popV || pushV.length == 0 || popV.length == 0) {
+        return;
+      }
+      var stack = [];
+      var idx = 0;
+      for (var i = 0; i < pushV.length; i++) {
+        stack.push(pushV[i]);
+        while (stack.length && stack[stack.length - 1] == popV[idx]) {
+          stack.pop();
+          idx++;
+        }
+      }
+      return stack.length == 0;
+    }
+
+```

docs/dataStructure/栈和队列/滑动窗口的最大值.md

@@ -0,0 +1,67 @@
+---
+{
+  "title": "滑动窗口的最大值",
+}
+---
+
+## 题目
+
+给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 k 内的数字。滑动窗口每次只向右移动一位。
+返回滑动窗口最大值。
+```js
+输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
+输出: [3,3,5,5,6,7] 
+解释: 
+  滑动窗口的位置                最大值
+---------------               -----
+[1  3  -1] -3  5  3  6  7       3
+ 1 [3  -1  -3] 5  3  6  7       3
+ 1  3 [-1  -3  5] 3  6  7       5
+ 1  3  -1 [-3  5  3] 6  7       5
+ 1  3  -1  -3 [5  3  6] 7       6
+ 1  3  -1  -3  5 [3  6  7]      7
+```
+
+## 思路
+
+使用一个双端队列（队列两面都可进出），用于存储处于窗口中的值的下标，保证窗口头部元素永远是窗口最大值
+- 1.当前进入的元素下标 - 窗口头部元素的下标 >= k 头部元素移出队列
+- 2.如果当前数字大于队列尾，则删除队列尾，直到当前数字小于等于队列尾，或者队列空 （保证窗口中左侧的值均大于当前入队列的值，这样做可以保证当下次循环窗口头部的元素出队后，窗口头部元素仍然为最大值）
+- 3.队列元素入队
+- 4.第k次遍历后开始向结果中添加最大值
+
+![](../../dist/img/滑动窗口的最大值.png)
+
+时间复杂度：`O(n)`
+
+空间复杂度：`O(n)`
+
+- 使用优先队列也可以实现，时间复杂度为`O(nlogk)` 
+
+## 代码
+
+```js
+    var maxSlidingWindow = function (nums, k) {
+      const window = [];
+      const result = [];
+      for (let i = 0; i < nums.length; i++) {
+        if (i - window[0] > k - 1) {
+          window.shift();
+        }
+        let j = window.length - 1;
+        while (j >= 0 && nums[window[j]] <= nums[i]) {
+          j--;
+          window.pop();
+        }
+        window.push(i);
+        if (i >= k - 1) {
+          result.push(nums[window[0]]);
+        }
+      }
+      return result;
+    };
+```
+
+## 考察点
+
+- 队列

docs/dataStructure/栈和队列/用两个栈实现队列.md

@@ -0,0 +1,82 @@
+---
+{
+  "title": "用两个栈实现队列",
+}
+---
+
+
+## 题目
+
+用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
+
+## 思路
+
+**栈1:**
+
+用于入队列存储
+
+**栈2:**
+
+出队列时将栈1的数据依次出栈，并入栈到栈2中
+
+栈2出栈即栈1的底部数据即队列要出的数据。
+
+**注意:**
+
+栈2为空才能补充栈1的数据，否则会打乱当前的顺序。
+
+![](../../dist/img/queue.png)
+
+## 代码
+
+
+```js
+const stack1 = [];
+const stack2 = [];
+
+function push(node)
+{
+    stack1.push(node);
+}
+function pop()
+{
+    if(stack2.length === 0){
+       while(stack1.length>0){
+        stack2.push(stack1.pop());
+       }
+    }
+    return stack2.pop() || null;
+}
+```
+
+
+## 扩展：用两个队列实现一个栈
+
+```js
+    const queue1 = []
+    const queue2 = []
+
+    function push(x) {
+      if (queue1.length === 0) {
+        queue1.push(x)
+
+        while (queue2.length) {
+          queue1.push(queue2.shift())
+        }
+      } else if (queue2.length === 0) {
+        queue2.push(x)
+
+        while (queue1.length) {
+          queue2.push(queue1.shift())
+        }
+      }
+    };
+
+    function pop() {
+      if (queue1.length !== 0) {
+        return queue1.shift()
+      } else {
+        return queue2.shift()
+      }
+    };
+```