添加题150,394,94

Author: ligecarryme

入门（Java）/JS实现.md renamed to 入门（Java）/经典算法JS实现.md

@@ -2,13 +2,13 @@
 
 ### 简介
 
-栈的特点是后入先出，根据这个特点可以临时保存一些数据，之后用到依次再弹出来，常用于 DFS 深度搜索
+**栈**的特点是后入先出，根据这个特点可以临时保存一些数据，之后用到依次再弹出来，常用于 DFS 深度搜索
 
-队列一般常用于 BFS 广度搜索，类似一层一层的搜索。
+**队列**一般常用于 BFS 广度搜索，类似一层一层的搜索。
 
 ### Stack 栈
 
-##### 155.最小栈 [min-stack](https://leetcode-cn.com/problems/min-stack/)
+##### [155.最小栈](https://leetcode-cn.com/problems/min-stack/)
 
 > 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
 
@@ -55,7 +55,104 @@ MinStack.prototype.getMin = function() {
 };
 ```
 
-##### 150.逆波兰表达式求值 [evaluate-reverse-polish-notation](https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/)
+##### [150.逆波兰表达式求值 ](https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/)
 
-##### 133.克隆图 [clone-graph](https://leetcode-cn.com/problems/clone-graph/)
+```js
+var evalRPN = function (tokens) {
+    const stack = []
+    for (const item of tokens) {
+        if (!isNaN(+item)) {
+            stack.push(item)
+        } else {
+            let res = 0
+            const top = parseInt(stack.pop()) //在栈中的位置靠上（被除数）
+            const down = parseInt(stack.pop()) //靠下（除数）
+            switch (item) {
+                case '+':
+                    res = top + down
+                    break
+                case '-':
+                    res = down - top
+                    break
+                case '*':
+                    res = top * down
+                    break
+                case '/':
+                    res = parseInt(down / top)
+                    break
+            }
+            stack.push(res)
+        }
+    }
+    return stack[0]
+};
+```
+
+##### [394. 字符串解码](https://leetcode-cn.com/problems/decode-string/)
+
+给定一个经过编码的字符串，返回它解码后的字符串。
+
+> 输入：s = "3[a]2[bc]"
+> 输出："aaabcbc"
+
+```js
+var decodeString = function (s) {
+    const stack = []
+    for (let i = 0; i < s.length; i++) {
+        const char = s[i]
+        if (char !== ']') {
+            stack.push(char)
+        } else {
+            let str = ''
+            while (stack.length > 0) {
+                const temp = stack.pop()
+                if (temp !== '[') {
+                    str = temp + str
+                } else {
+                    let num = ''
+                    while (stack.length > 0) {
+                        const tempNum = stack.pop() // 处理类似100的数字，此时栈中['1','0','0']
+                        if (!isNaN(tempNum)) {
+                            num = tempNum + num
+                        } else {
+                            stack.push(tempNum)
+                            break
+                        }
+                    }
+                    str = str.repeat(+num)
+                    break
+                }
+            }
+            stack.push(str)
+        }
+    }
+    return stack.join('')
+}
+```
+
+##### [94. 二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
+
+```js
+var inorderTraversal = function (root) { //递归写法
+    if (root === null) {
+        return []
+    }
+    const res = [];
+    (function inOrder(root) {
+        if (!root) {
+            return
+        }
+        inOrder(root.left)
+        res.push(root.val)
+        inOrder(root.right)
+    })(root);
+    return res
+};
+```
+
+```js
+
+```
+
+##### [133.克隆图](https://leetcode-cn.com/problems/clone-graph/)