diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/README.md b/solution/0700-0799/0700.Search in a Binary Search Tree/README.md
index 5d436aebdcfae..f8bbe42943156 100644
--- a/solution/0700-0799/0700.Search in a Binary Search Tree/README.md	
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/README.md	
@@ -32,7 +32,6 @@
 
 <p>在上述示例中，如果要找的值是 <code>5</code>，但因为没有节点值为 <code>5</code>，我们应该返回 <code>NULL</code>。</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -44,7 +43,21 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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 searchBST(self, root: TreeNode, val: int) -> TreeNode:
+        if root is None:
+            return None
+        if root.val == val:
+            return root
+        if root.val < val:
+            return self.searchBST(root.right, val)
+        return self.searchBST(root.left, val)
 ```
 
 ### **Java**
@@ -52,7 +65,85 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```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 searchBST(TreeNode root, int val) {
+        if (root == null) {
+            return null;
+        }
+        if (root.val == val) {
+            return root;
+        }
+        if (root.val < val) {
+            return searchBST(root.right, val);
+        }
+        return searchBST(root.left, val);
+    }
+}
+```
+
+### **C++**
+
+```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* searchBST(TreeNode* root, int val) {
+        if (root == nullptr) return nullptr;
+        if (root->val == val) return root;
+        if (root->val < val) return searchBST(root->right, val);
+        return searchBST(root->left, val);
+    }
+};
+```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func searchBST(root *TreeNode, val int) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	if root.Val == val {
+		return root
+	}
+	if root.Val < val {
+		return searchBST(root.Right, val)
+	}
+	return searchBST(root.Left, val)
+}
 ```
 
 ### **...**
diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/README_EN.md b/solution/0700-0799/0700.Search in a Binary Search Tree/README_EN.md
index 354dd229850b5..0972880de8464 100644
--- a/solution/0700-0799/0700.Search in a Binary Search Tree/README_EN.md	
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/README_EN.md	
@@ -33,7 +33,6 @@
 	<li><code>1 &lt;= val &lt;= 10<sup>7</sup></code></li>
 </ul>
 
-
 ## Solutions
 
 <!-- tabs:start -->
@@ -41,13 +40,105 @@
 ### **Python3**
 
 ```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 searchBST(self, root: TreeNode, val: int) -> TreeNode:
+        if root is None:
+            return None
+        if root.val == val:
+            return root
+        if root.val < val:
+            return self.searchBST(root.right, val)
+        return self.searchBST(root.left, val)
 ```
 
 ### **Java**
 
 ```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 searchBST(TreeNode root, int val) {
+        if (root == null) {
+            return null;
+        }
+        if (root.val == val) {
+            return root;
+        }
+        if (root.val < val) {
+            return searchBST(root.right, val);
+        }
+        return searchBST(root.left, val);
+    }
+}
+```
+
+### **C++**
+
+```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* searchBST(TreeNode* root, int val) {
+        if (root == nullptr) return nullptr;
+        if (root->val == val) return root;
+        if (root->val < val) return searchBST(root->right, val);
+        return searchBST(root->left, val);
+    }
+};
+```
 
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func searchBST(root *TreeNode, val int) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	if root.Val == val {
+		return root
+	}
+	if root.Val < val {
+		return searchBST(root.Right, val)
+	}
+	return searchBST(root.Left, val)
+}
 ```
 
 ### **...**
diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.cpp b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.cpp
index 5461901931b8a..3b87d7d24e281 100644
--- a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.cpp	
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.cpp	
@@ -4,27 +4,17 @@
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     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:
+public:
     TreeNode* searchBST(TreeNode* root, int val) {
-
-        TreeNode* temp = root;
-
-        while( temp != NULL ){
-            if( temp->val == val ){
-                return temp;
-            }
-            else if( val < temp->val ){
-                temp = temp->left;
-            }
-            else{
-                temp = temp->right;
-            }
-        }
-
-        return NULL;
+        if (root == nullptr) return nullptr;
+        if (root->val == val) return root;
+        if (root->val < val) return searchBST(root->right, val);
+        return searchBST(root->left, val);
     }
-};
+};
\ No newline at end of file
diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.go b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.go
new file mode 100644
index 0000000000000..2ce9bb630ecf2
--- /dev/null
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.go	
@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func searchBST(root *TreeNode, val int) *TreeNode {
+	if root == nil {
+		return nil
+	}
+	if root.Val == val {
+		return root
+	}
+	if root.Val < val {
+		return searchBST(root.Right, val)
+	}
+	return searchBST(root.Left, val)
+}
\ No newline at end of file
diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.java b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.java
index 0bda84ced2619..cb752fe7e0bcf 100644
--- a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.java	
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.java	
@@ -4,14 +4,26 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     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 searchBST(TreeNode root, int val) {
-        if (root == null) return null;
-        if (root.val == val) return root;
-        if (root.val < val) return searchBST(root.right, val);
-        else return searchBST(root.left, val);
+        if (root == null) {
+            return null;
+        }
+        if (root.val == val) {
+            return root;
+        }
+        if (root.val < val) {
+            return searchBST(root.right, val);
+        }
+        return searchBST(root.left, val);
     }
-}
+}
\ No newline at end of file
diff --git a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.py b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.py
index 9dae363047096..f726af72e8997 100644
--- a/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.py	
+++ b/solution/0700-0799/0700.Search in a Binary Search Tree/Solution.py	
@@ -1,27 +1,15 @@
 # Definition for a binary tree node.
 # class TreeNode:
-#     def __init__(self, x):
-#         self.val = x
-#         self.left = None
-#         self.right = None
-
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
 class Solution:
-    def searchBST(self, root, val):
-        """
-        :type root: TreeNode
-        :type val: int
-        :rtype: TreeNode
-        """
-
-        temp = root
-
-        while temp != None :
-
-            if temp.val == val :
-                return temp
-            elif val < temp.val :
-                temp = temp.left
-            else:
-                temp = temp.right
-
-        return None
+    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
+        if root is None:
+            return None
+        if root.val == val:
+            return root
+        if root.val < val:
+            return self.searchBST(root.right, val)
+        return self.searchBST(root.left, val)