feat: add solutions to lc problem: No.0099

No.0099.Recover Binary Search Tree

Author: yanglbme

solution/0000-0099/0099.Recover Binary Search Tree/README.md

@@ -42,6 +42,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：中序遍历**
+
+中序遍历二叉搜索树，得到的序列是递增的。如果有两个节点的值被错误地交换，那么中序遍历得到的序列中，一定会出现两个逆序对。我们用 `first` 和 `second` 分别记录这两个逆序对中较小值和较大值的节点，最后交换这两个节点的值即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -60,18 +66,17 @@ class Solution:
         """
         Do not return anything, modify root in-place instead.
         """
-
         def dfs(root):
+            if root is None:
+                return
             nonlocal prev, first, second
-            if root:
-                dfs(root.left)
-                if prev:
-                    if first is None and root.val < prev.val:
-                        first = prev
-                    if first and root.val < prev.val:
-                        second = root
-                prev = root
-                dfs(root.right)
+            dfs(root.left)
+            if prev and prev.val > root.val:
+                if first is None:
+                    first = prev
+                second = root
+            prev = root
+            dfs(root.right)
 
         prev = first = second = None
         dfs(root)
@@ -115,13 +120,11 @@ class Solution {
             return;
         }
         dfs(root.left);
-        if (prev != null) {
-            if (first == null && prev.val > root.val) {
+        if (prev != null && prev.val > root.val) {
+            if (first == null) {
                 first = prev;
             }
-            if (first != null && prev.val > root.val) {
-                second = root;
-            }
+            second = root;
         }
         prev = root;
         dfs(root.right);
@@ -145,25 +148,23 @@ class Solution {
  */
 class Solution {
 public:
-    TreeNode* prev;
-    TreeNode* first;
-    TreeNode* second;
-
     void recoverTree(TreeNode* root) {
+        TreeNode* prev = nullptr;
+        TreeNode* first = nullptr;
+        TreeNode* second = nullptr;
+        function<void(TreeNode* root)> dfs = [&](TreeNode* root) {
+            if (!root) return;
+            dfs(root->left);
+            if (prev && prev->val > root->val) {
+                if (!first) first = prev;
+                second = root;
+            }
+            prev = root;
+            dfs(root->right);
+        };
         dfs(root);
         swap(first->val, second->val);
     }
-
-    void dfs(TreeNode* root) {
-        if (!root) return;
-        dfs(root->left);
-        if (prev) {
-            if (!first && prev->val > root->val) first = prev;
-            if (first && prev->val > root->val) second = root;
-        }
-        prev = root;
-        dfs(root->right);
-    }
 };
 ```
 
@@ -179,28 +180,22 @@ public:
  * }
  */
 func recoverTree(root *TreeNode) {
-	var prev *TreeNode
-	var first *TreeNode
-	var second *TreeNode
-
-	var dfs func(root *TreeNode)
+	var prev, first, second *TreeNode
+	var dfs func(*TreeNode)
 	dfs = func(root *TreeNode) {
 		if root == nil {
 			return
 		}
 		dfs(root.Left)
-		if prev != nil {
-			if first == nil && prev.Val > root.Val {
+		if prev != nil && prev.Val > root.Val {
+			if first == nil {
 				first = prev
 			}
-			if first != nil && prev.Val > root.Val {
-				second = root
-			}
+			second = root
 		}
 		prev = root
 		dfs(root.Right)
 	}
-
 	dfs(root)
 	first.Val, second.Val = second.Val, first.Val
 }
@@ -233,23 +228,18 @@ public class Solution {
     }
 
     private void dfs(TreeNode root) {
-        if (root != null)
-        {
-            dfs(root.left);
-            if (prev != null)
-            {
-                if (first == null && prev.val > root.val)
-                {
-                    first = prev;
-                }
-                if (first != null && prev.val > root.val)
-                {
-                    second = root;
-                }
+        if (root == null) {
+            return;
+        }
+        dfs(root.left);
+        if (prev != null && prev.val > root.val) {
+            if (first == null) {
+                first = prev;
             }
-            prev = root;
-            dfs(root.right);
+            second = root;
         }
+        prev = root;
+        dfs(root.right);
     }
 }
 ```
@@ -269,34 +259,28 @@ public class Solution {
  * @param {TreeNode} root
  * @return {void} Do not return anything, modify root in-place instead.
  */
-const recoverTree = root => {
-    const data = {
-        prev: null,
-        first: null,
-        second: null,
-    };
-    let tmp = 0;
-
-    helper(root, data);
-
-    tmp = data.first.val;
-    data.first.val = data.second.val;
-    data.second.val = tmp;
-};
-
-const helper = (root, data) => {
-    if (!root) return;
-
-    helper(root.left, data);
-
-    if (data.prev && data.prev.val >= root.val) {
-        if (!data.first) data.first = data.prev;
-        data.second = root;
+var recoverTree = function (root) {
+    let prev = null;
+    let first = null;
+    let second = null;
+    function dfs(root) {
+        if (!root) {
+            return;
+        }
+        dfs(root.left);
+        if (prev && prev.val > root.val) {
+            if (!first) {
+                first = prev;
+            }
+            second = root;
+        }
+        prev = root;
+        dfs(root.right);
     }
-
-    data.prev = root;
-
-    helper(root.right, data);
+    dfs(root);
+    const t = first.val;
+    first.val = second.val;
+    second.val = t;
 };
 ```