feat: add solutions to leetcode problem: No.0426

See https://leetcode-cn.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/

Author: yanglbme

README.md

@@ -102,6 +102,7 @@
 1. [二叉树的最近公共祖先](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README.md)
 1. [二叉搜索树的最近公共祖先](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README.md)
 1. [将二叉搜索树转换为单链表](/lcci/17.12.BiNode/README.md)
+1. [将二叉搜索树转化为排序的双向链表](/solution/0400-0499/0426.Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List/README.md)
 
 ### 数学
 

README_EN.md

@@ -98,6 +98,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 1. [Lowest Common Ancestor of a Binary Tree](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README_EN.md)
 1. [Lowest Common Ancestor of a Binary Search Tree](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README_EN.md)
 1. [BiNode](/lcci/17.12.BiNode/README_EN.md)
+1. [Convert Binary Search Tree to Sorted Doubly Linked List](/solution/0400-0499/0426.Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List/README_EN.md)
 
 ### Math
 

lcof/面试题36. 二叉搜索树与双向链表/README.md

@@ -26,9 +26,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二叉搜索树中序遍历得到有序序列；根结点指向左子树最后一个结点，根结点也指向右子树第一个结点。
-
-利用虚拟头结点递归遍历求解。
+- 排序链表：二叉搜索树中序遍历得到有序序列
+- 循环链表：头节点指向链表尾节点，尾节点指向链表头节点
+- 双向链表：`pre.right = cur`、`cur.left = pre`、`pre = cur`
 
 <!-- tabs:start -->
 
@@ -45,29 +45,26 @@ class Node:
         self.left = left
         self.right = right
 """
-
-
 class Solution:
     def treeToDoublyList(self, root: 'Node') -> 'Node':
         def dfs(cur):
-            if not cur:
+            if cur is None:
                 return
             dfs(cur.left)
-            cur.left = self.lastNode
-            if self.lastNode:
-                self.lastNode.right = cur
-            self.lastNode = cur
+            if self.pre is None:
+                self.head = cur
+            else:
+                self.pre.right = cur
+            cur.left = self.pre
+            self.pre = cur
             dfs(cur.right)
-
-        if not root:
-            return root
-        self.lastNode = head = Node(-1)
+        if root is None:
+            return None
+        self.head = self.pre = None
         dfs(root)
-        head = head.right
-        head.left = self.lastNode
-        self.lastNode.right = head
-        return head
-
+        self.head.left = self.pre
+        self.pre.right = self.head
+        return self.head
 ```
 
 ### **Java**
@@ -96,30 +93,23 @@ class Node {
 };
 */
 class Solution {
-    private Node lastNode;
+    Node head;
+    Node pre;
     public Node treeToDoublyList(Node root) {
-        if (root == null) {
-            return root;
-        }
-        lastNode = new Node(-1);
-        Node head = lastNode;
+        if (root == null) return null;
         dfs(root);
-        head = head.right;
-        head.left = lastNode;
-        lastNode.right = head;
+        head.left = pre;
+        pre.right = head;
         return head;
     }
 
     private void dfs(Node cur) {
-        if (cur == null) {
-            return;
-        }
+        if (cur == null) return;
         dfs(cur.left);
-        cur.left = lastNode;
-        if (lastNode != null) {
-            lastNode.right = cur;
-        }
-        lastNode = cur;
+        if (pre == null) head = cur;
+        else pre.right = cur;
+        cur.left = pre;
+        pre = cur;
         dfs(cur.right);
     }
 }
@@ -130,41 +120,32 @@ class Solution {
 ```js
 /**
  * // Definition for a Node.
- * function Node(val, left, right) {
- *      this.val = val;
- *      this.left = left;
- *      this.right = right;
- *  };
+ * function Node(val,left,right) {
+ *    this.val = val;
+ *    this.left = left;
+ *    this.right = right;
+ * };
  */
 /**
  * @param {Node} root
  * @return {Node}
  */
 var treeToDoublyList = function (root) {
-  if (!root) return null;
-  function dfs(node) {
-    if (!node) return null;
-    dfs(node.left);
-    arr.push(node);
-    dfs(node.right);
+  function dfs(cur) {
+    if (!cur) return;
+    dfs(cur.left);
+    if (!pre) head = cur;
+    else pre.right = cur;
+    cur.left = pre;
+    pre = cur;
+    dfs(cur.right);
   }
-  let arr = [];
+  if (!root) return null;
+  let head, pre;
   dfs(root);
-  let len = arr.length;
-  let res = arr[0];
-  for (let i = 0; i < len; i++) {
-    if (i + 1 < len) {
-      arr[i].right = arr[i + 1];
-    } else {
-      arr[i].right = arr[0];
-    }
-    if (i - 1 >= 0) {
-      arr[i].left = arr[i - 1];
-    } else {
-      arr[i].left = arr[len - 1];
-    }
-  }
-  return res;
+  head.left = pre;
+  pre.right = head;
+  return head;
 };
 ```
 

lcof/面试题36. 二叉搜索树与双向链表/Solution.java

@@ -19,30 +19,23 @@ public Node(int _val,Node _left,Node _right) {
 };
 */
 class Solution {
-    private Node lastNode;
+    Node head;
+    Node pre;
     public Node treeToDoublyList(Node root) {
-        if (root == null) {
-            return root;
-        }
-        lastNode = new Node(-1);
-        Node head = lastNode;
+        if (root == null) return null;
         dfs(root);
-        head = head.right;
-        head.left = lastNode;
-        lastNode.right = head;
+        head.left = pre;
+        pre.right = head;
         return head;
     }
 
     private void dfs(Node cur) {
-        if (cur == null) {
-            return;
-        }
+        if (cur == null) return;
         dfs(cur.left);
-        cur.left = lastNode;
-        if (lastNode != null) {
-            lastNode.right = cur;
-        }
-        lastNode = cur;
+        if (pre == null) head = cur;
+        else pre.right = cur;
+        cur.left = pre;
+        pre = cur;
         dfs(cur.right);
     }
 }

lcof/面试题36. 二叉搜索树与双向链表/Solution.js

@@ -1,38 +1,29 @@
 /**
  * // Definition for a Node.
- * function Node(val, left, right) {
- *      this.val = val;
- *      this.left = left;
- *      this.right = right;
- *  };
+ * function Node(val,left,right) {
+ *    this.val = val;
+ *    this.left = left;
+ *    this.right = right;
+ * };
  */
 /**
  * @param {Node} root
  * @return {Node}
  */
 var treeToDoublyList = function (root) {
-  if (!root) return null;
-  function dfs(node) {
-    if (!node) return null;
-    dfs(node.left);
-    arr.push(node);
-    dfs(node.right);
+  function dfs(cur) {
+    if (!cur) return;
+    dfs(cur.left);
+    if (!pre) head = cur;
+    else pre.right = cur;
+    cur.left = pre;
+    pre = cur;
+    dfs(cur.right);
   }
-  let arr = [];
+  if (!root) return null;
+  let head, pre;
   dfs(root);
-  let len = arr.length;
-  let res = arr[0];
-  for (let i = 0; i < len; i++) {
-    if (i + 1 < len) {
-      arr[i].right = arr[i + 1];
-    } else {
-      arr[i].right = arr[0];
-    }
-    if (i - 1 >= 0) {
-      arr[i].left = arr[i - 1];
-    } else {
-      arr[i].left = arr[len - 1];
-    }
-  }
-  return res;
+  head.left = pre;
+  pre.right = head;
+  return head;
 };

lcof/面试题36. 二叉搜索树与双向链表/Solution.py

@@ -6,25 +6,23 @@ def __init__(self, val, left=None, right=None):
         self.left = left
         self.right = right
 """
-
-
 class Solution:
     def treeToDoublyList(self, root: 'Node') -> 'Node':
         def dfs(cur):
-            if not cur:
+            if cur is None:
                 return
             dfs(cur.left)
-            cur.left = self.lastNode
-            if self.lastNode:
-                self.lastNode.right = cur
-            self.lastNode = cur
+            if self.pre is None:
+                self.head = cur
+            else:
+                self.pre.right = cur
+            cur.left = self.pre
+            self.pre = cur
             dfs(cur.right)
-
-        if not root:
-            return root
-        self.lastNode = head = Node(-1)
+        if root is None:
+            return None
+        self.head = self.pre = None
         dfs(root)
-        head = head.right
-        head.left = self.lastNode
-        self.lastNode.right = head
-        return head
+        self.head.left = self.pre
+        self.pre.right = self.head
+        return self.head

solution/0000-0099/0020.Valid Parentheses/README.md

@@ -97,6 +97,27 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> q;
+        for (int i = 0, n = s.length(); i < n; ++i) {
+            if (s[i] == '{' || s[i] == '[' || s[i] == '(') q.push(s[i]);
+            else if (q.empty() || !match(q.top(), s[i])) return false;
+            else q.pop();
+        }
+        return q.empty();
+    }
+private:
+    bool match(char l, char r) {
+        return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}');
+    }
+};
+```
+
 ### **...**
 
 ```

solution/0000-0099/0020.Valid Parentheses/README_EN.md

@@ -105,6 +105,27 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> q;
+        for (int i = 0, n = s.length(); i < n; ++i) {
+            if (s[i] == '{' || s[i] == '[' || s[i] == '(') q.push(s[i]);
+            else if (q.empty() || !match(q.top(), s[i])) return false;
+            else q.pop();
+        }
+        return q.empty();
+    }
+private:
+    bool match(char l, char r) {
+        return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}');
+    }
+};
+```
+
 ### **...**
 
 ```