feat: add solutions to lc problem: No.0235

No.0235.Lowest Common Ancestor of a Binary Search Tree

Author: yanglbme

solution/0200-0299/0234.Palindrome Linked List/README.md

@@ -60,9 +60,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def isPalindrome(self, head: ListNode) -> bool:
-        if head is None or head.next is None:
-            return True
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
         slow, fast = head, head.next
         while fast and fast.next:
             slow, fast = slow.next, fast.next.next

solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md

@@ -42,7 +42,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-从上到下搜索，找到第一个值位于 `[p, q]` 之间的结点即可。既可以用迭代实现，也可以用递归实现。
+**方法一：迭代或递归**
+
+从上到下搜索，找到第一个值位于 $[p.val, q.val]$ 之间的结点即可。
+
+既可以用迭代实现，也可以用递归实现。
+
+迭代的时间复杂度为 $O(n)$，空间复杂度为 $O(1)$。
+
+递归的时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。
 
 <!-- tabs:start -->
 
@@ -65,7 +73,7 @@ class Solution:
     def lowestCommonAncestor(
         self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'
     ) -> 'TreeNode':
-        while root:
+        while 1:
             if root.val < min(p.val, q.val):
                 root = root.right
             elif root.val > max(p.val, q.val):
@@ -84,10 +92,11 @@ class Solution:
 #         self.left = None
 #         self.right = None
 
+
 class Solution:
-    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
-        if root is None:
-            return None
+    def lowestCommonAncestor(
+        self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'
+    ) -> 'TreeNode':
         if root.val < min(p.val, q.val):
             return self.lowestCommonAncestor(root.right, p, q)
         if root.val > max(p.val, q.val):
@@ -114,12 +123,15 @@ class Solution:
 
 class Solution {
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        while (root != null) {
-            if (root.val < p.val && root.val < q.val) root = root.right;
-            else if (root.val > p.val && root.val > q.val) root = root.left;
-            else return root;
+        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;
+            }
         }
-        return root;
     }
 }
 ```
@@ -139,78 +151,73 @@ class Solution {
 
 class Solution {
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        if (root == null) return null;
-        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 < 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;
     }
 }
 ```
 
-### **TypeScript**
+### **C++**
 
 迭代：
 
-```ts
+```cpp
 /**
  * Definition for a binary tree node.
- * class TreeNode {
- *     val: number
- *     left: TreeNode | null
- *     right: TreeNode | null
- *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.left = (left===undefined ? null : left)
- *         this.right = (right===undefined ? null : right)
- *     }
- * }
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
  */
 
-function lowestCommonAncestor(
-    root: TreeNode | null,
-    p: TreeNode | null,
-    q: TreeNode | null,
-): TreeNode | null {
-    while (root) {
-        if (root.val > p.val && root.val > q.val) {
-            root = root.left;
-        } else if (root.val < p.val && root.val < q.val) {
-            root = root.right;
-        } else {
-            return root;
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        while (1) {
+            if (root->val < min(p->val, q->val)) {
+                root = root->right;
+            } else if (root->val > max(p->val, q->val)) {
+                root = root->left;
+            } else {
+                return root;
+            }
         }
     }
-}
+};
 ```
 
 递归：
 
-```ts
+```cpp
 /**
  * Definition for a binary tree node.
- * class TreeNode {
- *     val: number
- *     left: TreeNode | null
- *     right: TreeNode | null
- *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
- *         this.val = (val===undefined ? 0 : val)
- *         this.left = (left===undefined ? null : left)
- *         this.right = (right===undefined ? null : right)
- *     }
- * }
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
  */
 
-function lowestCommonAncestor(
-    root: TreeNode | null,
-    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);
-    return root;
-}
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        if (root->val < min(p->val, q->val)) {
+            return lowestCommonAncestor(root->right, p, q);
+        }
+        if (root->val > max(p->val, q->val)) {
+            return lowestCommonAncestor(root->left, p, q);
+        }
+        return root;
+    }
+};
 ```
 
 ### **Go**
@@ -228,16 +235,15 @@ function lowestCommonAncestor(
  */
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
-	for root != nil {
-		if root.Val > p.Val && root.Val > q.Val {
-			root = root.Left
-		} else if root.Val < p.Val && root.Val < q.Val {
+	for {
+		if root.Val < p.Val && root.Val < q.Val {
 			root = root.Right
+		} else if root.Val > p.Val && root.Val > q.Val {
+			root = root.Left
 		} else {
 			return root
 		}
 	}
-	return nil
 }
 ```
 
@@ -254,72 +260,86 @@ func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
  */
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
-    if root == nil {
-        return root
-    }
-    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)
-    }
-    return root
+	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)
+	}
+	return root
 }
 ```
 
-### **C++**
+### **TypeScript**
 
 迭代：
 
-```cpp
+```ts
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
  */
 
-class Solution {
-public:
-    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
-        while (root) {
-            if (root->val < p->val && root->val < q->val)
-                root = root->right;
-            else if (root->val > p->val && root->val > q->val)
-                root = root->left;
-            else
-                return root;
+function lowestCommonAncestor(
+    root: TreeNode | null,
+    p: TreeNode | null,
+    q: TreeNode | null,
+): TreeNode | null {
+    while (root) {
+        if (root.val > p.val && root.val > q.val) {
+            root = root.left;
+        } else if (root.val < p.val && root.val < q.val) {
+            root = root.right;
+        } else {
+            return root;
         }
-        return root;
     }
-};
+}
 ```
 
 递归：
 
-```cpp
+```ts
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
  */
 
-class Solution {
-public:
-    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
-        if (!root) return root;
-        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);
-        return root;
-    }
-};
+function lowestCommonAncestor(
+    root: TreeNode | null,
+    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);
+    return root;
+}
+```
+
+### **...**
+
+```
+
 ```
 
 <!-- tabs:end -->