feat: add solutions to lc problem: No.0669

No.0669.Trim a Binary Search Tree

Author: yanglbme

solution/0600-0699/0669.Trim a Binary Search Tree/README.md

@@ -42,6 +42,34 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：递归**
+
+判断 `root.val` 与 `low` 和 `high` 的大小关系：
+
+-   若 `root.val` 大于 `high`，说明当前 `root` 节点与其右子树所有节点的值均大于 `high`，那么递归修剪 `root.left` 即可；
+-   若 `root.val` 小于 `low`，说明当前 `root` 节点与其左子树所有节点的值均小于 `low`，那么递归修剪 `root.right` 即可；
+-   若 `root.val` 在 `[low, high]` 之间，说明当前 `root` 应该保留，递归修剪 `root.left`, `root.right`，并且返回 `root`。
+
+递归的终止条件是 `root` 节点为空。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点个数。
+
+**方法二：迭代**
+
+我们先循环判断 `root`，若 `root.val` 不在 `[low, high]` 之间，那么直接将 `root` 置为对应的左孩子或右孩子，循环直至 `root` 为空或者 `root.val` 在 `[low, high]` 之间。
+
+若此时 `root` 为空，直接返回。否则，说明 `root` 是一个需要保留的节点。接下来只需要分别迭代修剪 `root` 的左右子树。
+
+以左子树 `node = root.left` 为例：
+
+-   若 `node.left.val` 小于 `low`，那么 `node.left` 及其左孩子均不满足条件，我们直接将 `node.left` 置为 `node.left.right`；
+-   否则，我们将 `node` 置为 `node.left`；
+-   循环判断，直至 `node.left` 为空。
+
+右子树的修剪过程与之类似。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是二叉搜索树的节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -73,6 +101,36 @@ class Solution:
         return dfs(root)
 ```
 
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def trimBST(
+        self, root: Optional[TreeNode], low: int, high: int
+    ) -> Optional[TreeNode]:
+        while root and (root.val < low or root.val > high):
+            root = root.left if root.val > high else root.right
+        if root is None:
+            return None
+        node = root
+        while node.left:
+            if node.left.val < low:
+                node.left = node.left.right
+            else:
+                node = node.left
+        node = root
+        while node.right:
+            if node.right.val > high:
+                node.right = node.right.left
+            else:
+                node = node.right
+        return root
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -111,6 +169,51 @@ class Solution {
 }
 ```
 
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        while (root != null && (root.val < low || root.val > high)) {
+            root = root.val < low ? root.right : root.left;
+        }
+        if (root == null) {
+            return null;
+        }
+        TreeNode node = root;
+        while (node.left != null) {
+            if (node.left.val < low) {
+                node.left = node.left.right;
+            } else {
+                node = node.left;
+            }
+        }
+        node = root;
+        while (node.right != null) {
+            if (node.right.val > high) {
+                node.right = node.right.left;
+            } else {
+                node = node.right;
+            }
+        }
+        return root;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -138,6 +241,48 @@ public:
 };
 ```
 
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* trimBST(TreeNode* root, int low, int high) {
+        while (root && (root->val < low || root->val > high)) {
+            root = root->val < low ? root->right : root->left;
+        }
+        if (!root) {
+            return root;
+        }
+        TreeNode* node = root;
+        while (node->left) {
+            if (node->left->val < low) {
+                node->left = node->left->right;
+            } else {
+                node = node->left;
+            }
+        }
+        node = root;
+        while (node->right) {
+            if (node->right->val > high) {
+                node->right = node->right->left;
+            } else {
+                node = node->right;
+            }
+        }
+        return root;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -165,6 +310,46 @@ func trimBST(root *TreeNode, low int, high int) *TreeNode {
 }
 ```
 
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func trimBST(root *TreeNode, low int, high int) *TreeNode {
+	for root != nil && (root.Val < low || root.Val > high) {
+		if root.Val < low {
+			root = root.Right
+		} else {
+			root = root.Left
+		}
+	}
+	if root == nil {
+		return nil
+	}
+	node := root
+	for node.Left != nil {
+		if node.Left.Val < low {
+			node.Left = node.Left.Right
+		} else {
+			node = node.Left
+		}
+	}
+	node = root
+	for node.Right != nil {
+		if node.Right.Val > high {
+			node.Right = node.Right.Left
+		} else {
+			node = node.Right
+		}
+	}
+	return root
+}
+```
+
 ### **...**
 
 ```