feat: add js solution for azl397985856#25 azl397985856#32 (azl397985856#338)

* feat(js-solution): add js-solution for problem 4

* feat(js-solution): add js solution for problem 25

* feat: azl397985856#32 栈解法

Author: feikerwu

problems/25.reverse-nodes-in-k-groups-cn.md

@@ -65,7 +65,7 @@ curr = temp;
 ![reverse k nodes in linked list](../assets/problems/25.reverse-nodes-in-k-groups-2.PNG)
 
 
->**NOTE**: 一般情况下对链表的操作，都有可能会引入一个新的`dummy node`，因为`head`有可能会改变。这里`head 从1->3`, 
+>**NOTE**: 一般情况下对链表的操作，都有可能会引入一个新的`dummy node`，因为`head`有可能会改变。这里`head 从1->3`,
 `dummy (List(0)) `保持不变。
 
 #### 复杂度分析
@@ -78,7 +78,7 @@ curr = temp;
 3. 对每一组进行翻转，更换起始和最后的位置
 4. 返回`dummy.next`.
 
-## 代码 (`Java/Python3`)
+## 代码 (`Java/Python3/javascript`)
 *Java Code*
 ```java
 class ReverseKGroupsLinkedList {
@@ -88,7 +88,7 @@ class ReverseKGroupsLinkedList {
       }
       ListNode dummy = new ListNode(0);
       dummy.next = head;
-  
+
       ListNode start = dummy;
       ListNode end = head;
       int count = 0;
@@ -105,21 +105,21 @@ class ReverseKGroupsLinkedList {
       }
       return dummy.next;
     }
-  
-    /** 
+
+    /**
      * reverse linked list from range (start, end), return last node.
-     * for example: 
+     * for example:
      * 0->1->2->3->4->5->6->7->8
      * |           |
      * start       end
-     * 
+     *
      * After call start = reverse(start, end)
-     * 
+     *
      * 0->3->2->1->4->5->6->7->8
      *          |  |
      *       start end
      *       first
-     * 
+     *
      */
     private ListNode reverse(ListNode start, ListNode end) {
       ListNode curr = start.next;
@@ -157,7 +157,7 @@ class Solution:
             else:
                 end = end.next
         return dummy.next
-    
+
     def reverse(self, start, end):
         prev, curr = start, start.next
         first = curr
@@ -168,7 +168,49 @@ class Solution:
             curr = temp
         start.next = prev
         first.next = curr
-        return first   
+        return first
+```
+
+*javascript code*
+```js
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var reverseKGroup = function(head, k) {
+  // 标兵
+  let dummy = new ListNode()
+  dummy.next = head
+  let [start, end] = [dummy, dummy.next]
+  let count = 0
+  while(end) {
+    count++
+    if (count % k === 0) {
+      start = reverseList(start, end.next)
+      end = start.next
+    } else {
+      end = end.next
+    }
+  }
+  return dummy.next
+
+  // 翻转stat -> end的链表
+  function reverseList(start, end) {
+    let [pre, cur] = [start, start.next]
+    const first = cur
+    while(cur !== end) {
+      let next = cur.next
+      cur.next = pre
+      pre = cur
+      cur = next
+    }
+    start.next = pre
+    first.next = cur
+    return first
+  }
+};
+
 ```
 
 ## 参考（References)
@@ -178,13 +220,13 @@ class Solution:
 
 - 要求从后往前以`k`个为一组进行翻转。**(字节跳动（ByteDance）面试题)**
 
-    例子，`1->2->3->4->5->6->7->8, k = 3`, 
-    
+    例子，`1->2->3->4->5->6->7->8, k = 3`,
+
     从后往前以`k=3`为一组，
-    - `6->7->8` 为一组翻转为`8->7->6`， 
-    - `3->4->5`为一组翻转为`5->4->3`. 
+    - `6->7->8` 为一组翻转为`8->7->6`，
+    - `3->4->5`为一组翻转为`5->4->3`.
     - `1->2`只有2个nodes少于`k=3`个，不翻转。
-    
+
     最后返回： `1->2->5->4->3->8->7->6`
 
 这里的思路跟从前往后以`k`个为一组进行翻转类似，可以进行预处理：

problems/32.longest-valid-parentheses.md

@@ -44,9 +44,15 @@ s = '(())())'
 1. 第3点特征, 需要检查的字符是s[i-1]和s[i-2-dp[i-1]], 根据定义可知: i-1 >= dp[i-1], 但是i-2不一定大于dp[i-1], 因此, 需要检查越界;
 3. 第4点特征最容易遗漏, 还有就是不需要检查越界, 因为根据定义可知: i >= dp[i], 所以dp[i-dp[i]]的边界情况是dp[0];
 
+## 思路(栈)
+主要思路和常规的括号解法一样，遇到'('入栈，遇到')'出栈，并计算两个括号之间的长度。
+因为这个题存在非法括号对的情况且求是合法括号对的最大长度 所以有两个注意点是:
+1. **栈中存的是符号的下标**
+2. **当栈为空时且当前扫描到的符号是')'时，需要将这个符号入栈作为分割符**
+
 ## 代码
 
-* 语言支持: Python
+* 语言支持: Python, javascript
 
 Python Code:
 ```
@@ -75,6 +81,29 @@ class Solution:
         return mlen
 ```
 
+javascript code:
+```js
+// 用栈来解
+var longestValidParentheses = function(s) {
+  let stack = new Array()
+  let longest = 0
+  stack.push(-1)
+  for(let i = 0; i < s.length; i++) {
+    if (s[i] === '(') {
+      stack.push(i)
+    } else {
+      stack.pop()
+      if (stack.length === 0) {
+        stack.push(i)
+      } else {
+        longest = Math.max(longest, i - stack[stack.length - 1])
+      }
+    }
+  }
+  return longest
+};
+```
+
 ## 扩展
 
 1. 如果判断的不仅仅只有'('和')', 还有'[', ']', '{'和'}', 该怎么办?