diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md
index 31998e5c3308e..14e84ddb16aed 100644
--- a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md	
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md	
@@ -32,7 +32,7 @@ tags:
 <p><strong>示例 1:</strong></p>
 
 <pre><strong>输入:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
-<strong>输出:</strong> 6 
+<strong>输出:</strong> 6
 <strong>解释: </strong>节点 <code>2 </code>和节点 <code>8 </code>的最近公共祖先是 <code>6。</code>
 </pre>
 
@@ -57,15 +57,11 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一：迭代或递归
+### 方法一：迭代
 
-从上到下搜索，找到第一个值位于 $[p.val, q.val]$ 之间的结点即可。
+我们从根节点开始遍历，如果当前节点的值小于 $\textit{p}$ 和 $\textit{q}$ 的值，说明 $\textit{p}$ 和 $\textit{q}$ 应该在当前节点的右子树，因此将当前节点移动到右子节点；如果当前节点的值大于 $\textit{p}$ 和 $\textit{q}$ 的值，说明 $\textit{p}$ 和 $\textit{q}$ 应该在当前节点的左子树，因此将当前节点移动到左子节点；否则说明当前节点就是 $\textit{p}$ 和 $\textit{q}$ 的最近公共祖先，返回当前节点即可。
 
-既可以用迭代实现，也可以用递归实现。
-
-迭代的时间复杂度为 $O(n)$，空间复杂度为 $O(1)$。
-
-递归的时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。
+时间复杂度 $O(n)$，其中 $n$ 是二叉搜索树的节点个数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -164,9 +160,9 @@ public:
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
 	for {
-		if root.Val < p.Val && root.Val < q.Val {
+		if root.Val < min(p.Val, q.Val) {
 			root = root.Right
-		} else if root.Val > p.Val && root.Val > q.Val {
+		} else if root.Val > max(p.Val, q.Val) {
 			root = root.Left
 		} else {
 			return root
@@ -209,13 +205,47 @@ function lowestCommonAncestor(
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val < Math.Min(p.val, q.val)) {
+                root = root.right;
+            } else if (root.val > Math.Max(p.val, q.val)) {
+                root = root.left;
+            } else {
+                return root;
+            }
+        }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### 方法二
+### 方法二：递归
+
+我们也可以使用递归的方法来解决这个问题。
+
+我们首先判断当前节点的值是否小于 $\textit{p}$ 和 $\textit{q}$ 的值，如果是，则递归遍历右子树；如果当前节点的值大于 $\textit{p}$ 和 $\textit{q}$ 的值，如果是，则递归遍历左子树；否则说明当前节点就是 $\textit{p}$ 和 $\textit{q}$ 的最近公共祖先，返回当前节点即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点个数。
 
 <!-- tabs:start -->
 
@@ -339,12 +369,42 @@ function lowestCommonAncestor(
     p: TreeNode | null,
     q: TreeNode | null,
 ): TreeNode | null {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    if (root.val > p.val && root.val > q.val) {
+        return lowestCommonAncestor(root.left, p, q);
+    }
+    if (root.val < p.val && root.val < q.val) {
+        return lowestCommonAncestor(root.right, p, q);
+    }
     return root;
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val < Math.Min(p.val, q.val)) {
+            return LowestCommonAncestor(root.right, p, q);
+        }
+        if (root.val > Math.Max(p.val, q.val)) {
+            return LowestCommonAncestor(root.left, p, q);
+        }
+        return root;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README_EN.md b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README_EN.md
index 9e5d7066ef095..1fe8be223eb17 100644
--- a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README_EN.md	
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README_EN.md	
@@ -64,7 +64,11 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Iteration
+
+Starting from the root node, we traverse the tree. If the current node's value is less than both $\textit{p}$ and $\textit{q}$ values, it means that $\textit{p}$ and $\textit{q}$ should be in the right subtree of the current node, so we move to the right child. If the current node's value is greater than both $\textit{p}$ and $\textit{q}$ values, it means that $\textit{p}$ and $\textit{q}$ should be in the left subtree, so we move to the left child. Otherwise, it means the current node is the lowest common ancestor of $\textit{p}$ and $\textit{q}$, so we return the current node.
+
+The time complexity is $O(n)$, where $n$ is the number of nodes in the binary search tree. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -163,9 +167,9 @@ public:
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
 	for {
-		if root.Val < p.Val && root.Val < q.Val {
+		if root.Val < min(p.Val, q.Val) {
 			root = root.Right
-		} else if root.Val > p.Val && root.Val > q.Val {
+		} else if root.Val > max(p.Val, q.Val) {
 			root = root.Left
 		} else {
 			return root
@@ -208,13 +212,47 @@ function lowestCommonAncestor(
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val < Math.Min(p.val, q.val)) {
+                root = root.right;
+            } else if (root.val > Math.Max(p.val, q.val)) {
+                root = root.left;
+            } else {
+                return root;
+            }
+        }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### Solution 2
+### Solution 2: Recursion
+
+We can also use a recursive approach to solve this problem.
+
+We first check if the current node's value is less than both $\textit{p}$ and $\textit{q}$ values. If it is, we recursively traverse the right subtree. If the current node's value is greater than both $\textit{p}$ and $\textit{q}$ values, we recursively traverse the left subtree. Otherwise, it means the current node is the lowest common ancestor of $\textit{p}$ and $\textit{q}$, so we return the current node.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the number of nodes in the binary search tree.
 
 <!-- tabs:start -->
 
@@ -338,12 +376,42 @@ function lowestCommonAncestor(
     p: TreeNode | null,
     q: TreeNode | null,
 ): TreeNode | null {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    if (root.val > p.val && root.val > q.val) {
+        return lowestCommonAncestor(root.left, p, q);
+    }
+    if (root.val < p.val && root.val < q.val) {
+        return lowestCommonAncestor(root.right, p, q);
+    }
     return root;
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val < Math.Min(p.val, q.val)) {
+            return LowestCommonAncestor(root.right, p, q);
+        }
+        if (root.val > Math.Max(p.val, q.val)) {
+            return LowestCommonAncestor(root.left, p, q);
+        }
+        return root;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.cs b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.cs
new file mode 100644
index 0000000000000..0c62318d00082
--- /dev/null
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.cs	
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val < Math.Min(p.val, q.val)) {
+                root = root.right;
+            } else if (root.val > Math.Max(p.val, q.val)) {
+                root = root.left;
+            } else {
+                return root;
+            }
+        }
+    }
+}
diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.go b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.go
index 46ac599a9e887..3985db3bf9472 100644
--- a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.go	
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution.go	
@@ -9,12 +9,12 @@
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
 	for {
-		if root.Val < p.Val && root.Val < q.Val {
+		if root.Val < min(p.Val, q.Val) {
 			root = root.Right
-		} else if root.Val > p.Val && root.Val > q.Val {
+		} else if root.Val > max(p.Val, q.Val) {
 			root = root.Left
 		} else {
 			return root
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.cs b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.cs
new file mode 100644
index 0000000000000..4b0f3a40385be
--- /dev/null
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.cs	
@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val < Math.Min(p.val, q.val)) {
+            return LowestCommonAncestor(root.right, p, q);
+        }
+        if (root.val > Math.Max(p.val, q.val)) {
+            return LowestCommonAncestor(root.left, p, q);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.ts b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.ts
index 767340ae6f213..47fd3383276dd 100644
--- a/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.ts	
+++ b/solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/Solution2.ts	
@@ -17,7 +17,11 @@ function lowestCommonAncestor(
     p: TreeNode | null,
     q: TreeNode | null,
 ): TreeNode | null {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    if (root.val > p.val && root.val > q.val) {
+        return lowestCommonAncestor(root.left, p, q);
+    }
+    if (root.val < p.val && root.val < q.val) {
+        return lowestCommonAncestor(root.right, p, q);
+    }
     return root;
 }