feat: add solutions to lc problem: No.0426

No.0426.Convert Binary Search Tree to Sorted Doubly Linked List

Author: yanglbme

solution/0400-0499/0426.Convert Binary Search Tree to Sorted Doubly Linked List/README.md

@@ -63,9 +63,9 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-- 排序链表：二叉搜索树中序遍历得到有序序列
-- 循环链表：头节点指向链表尾节点，尾节点指向链表头节点
-- 双向链表：`pre.right = cur`、`cur.left = pre`、`pre = cur`
+-   排序链表：二叉搜索树中序遍历得到有序序列
+-   循环链表：头节点指向链表尾节点，尾节点指向链表头节点
+-   双向链表：`prev.right = cur`、`cur.left = prev`、`prev = cur`
 
 <!-- tabs:start -->
 
@@ -82,26 +82,30 @@ class Node:
         self.left = left
         self.right = right
 """
+
+
 class Solution:
-    def treeToDoublyList(self, root: 'Node') -> 'Node':
-        def dfs(cur):
-            if cur is None:
+    def treeToDoublyList(self, root: 'Optional[Node]') -> 'Optional[Node]':
+        def dfs(root):
+            if root is None:
                 return
-            dfs(cur.left)
-            if self.pre is None:
-                self.head = cur
+            nonlocal prev, head
+            dfs(root.left)
+            if prev:
+                prev.right = root
+                root.left = prev
             else:
-                self.pre.right = cur
-            cur.left = self.pre
-            self.pre = cur
-            dfs(cur.right)
+                head = root
+            prev = root
+            dfs(root.right)
+
         if root is None:
             return None
-        self.head = self.pre = None
+        head = prev = None
         dfs(root)
-        self.head.left = self.pre
-        self.pre.right = self.head
-        return self.head
+        prev.right = head
+        head.left = prev
+        return head
 ```
 
 ### **Java**
@@ -131,26 +135,132 @@ class Node {
 */
 
 class Solution {
+    private Node prev;
     private Node head;
-    private Node pre;
 
     public Node treeToDoublyList(Node root) {
-        if (root == null) return null;
+        if (root == null) {
+            return null;
+        }
+        prev = null;
+        head = null;
+        dfs(root);
+        prev.right = head;
+        head.left = prev;
+        return head;
+    }
+
+    private void dfs(Node root) {
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        if (prev != null) {
+            prev.right = root;
+            root.left = prev;
+        } else {
+            head = root;
+        }
+        prev = root;
+        dfs(root.right);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+        left = NULL;
+        right = NULL;
+    }
+
+    Node(int _val, Node* _left, Node* _right) {
+        val = _val;
+        left = _left;
+        right = _right;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* prev;
+    Node* head;
+
+    Node* treeToDoublyList(Node* root) {
+        if (!root) return nullptr;
+        prev = nullptr;
+        head = nullptr;
         dfs(root);
-        head.left = pre;
-        pre.right = head;
+        prev->right = head;
+        head->left = prev;
         return head;
     }
 
-    private void dfs(Node cur) {
-        if (cur == null) return;
-        dfs(cur.left);
-        if (pre == null) head = cur;
-        else pre.right = cur;
-        cur.left = pre;
-        pre = cur;
-        dfs(cur.right);
+    void dfs(Node* root) {
+        if (!root) return;
+        dfs(root->left);
+        if (prev)
+        {
+            prev->right = root;
+            root->left = prev;
+        }
+        else head = root;
+        prev = root;
+        dfs(root->right);
     }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ * }
+ */
+
+func treeToDoublyList(root *Node) *Node {
+	if root == nil {
+		return root
+	}
+	var prev, head *Node
+
+	var dfs func(root *Node)
+	dfs = func(root *Node) {
+		if root == nil {
+			return
+		}
+		dfs(root.Left)
+		if prev != nil {
+			prev.Right = root
+			root.Left = prev
+		} else {
+			head = root
+		}
+		prev = root
+		dfs(root.Right)
+	}
+	dfs(root)
+	prev.Right = head
+	head.Left = prev
+	return head
 }
 ```
 
@@ -159,31 +269,37 @@ 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) {
-    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);
+    if (!root) return root;
+    let prev = null;
+    let head = null;
+
+    function dfs(root) {
+        if (!root) return;
+        dfs(root.left);
+        if (prev) {
+            prev.right = root;
+            root.left = prev;
+        } else {
+            head = root;
+        }
+        prev = root;
+        dfs(root.right);
     }
-    if (!root) return null;
-    let head, pre;
     dfs(root);
-    head.left = pre;
-    pre.right = head;
+    prev.right = head;
+    head.left = prev;
     return head;
 };
 ```