feat: add solutions to lcof problem: No.68

Author: yanglbme

lcof/面试题65. 不用加减乘除做加法/README.md

@@ -28,9 +28,9 @@
 
 **方法一：位运算**
 
-两数字 `a`,`b` 求和。
+两数字 $a$, $b$ 求和。
 
-假设 $a_i$ 和 $b_i$ 分别表示 `a`、`b` 的第 $i$ 个二进制位。一共有 4 种情况：
+假设 $a_i$ 和 $b_i$ 分别表示 $a$ 和 $b$ 的第 $i$ 个二进制位。一共有 $4$ 种情况：
 
 | $a_i$ | $b_i$ | 不进位的和 | 进位 |
 | ----- | ----- | ---------- | ---- |
@@ -44,7 +44,9 @@
 -   对两数进行按位 `&` 与运算，然后左移一位，得到进位；
 -   对两数进行按位 `^` 异或运算，得到不进位的和；
 -   问题转换为求：“不进位的数 + 进位” 之和；
--   循环，直至进位为 0，返回不进位的数即可（也可以用递归实现）。
+-   循环，直至进位为 $0$，返回不进位的数即可（也可以用递归实现）。
+
+时间复杂度 $O(\log M)$，空间复杂度 $O(1)$。其中 $M$ 为整数的最大值。
 
 <!-- tabs:start -->
 
@@ -68,8 +70,6 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-迭代：
-
 ```java
 class Solution {
     public int add(int a, int b) {
@@ -83,8 +83,6 @@ class Solution {
 }
 ```
 
-递归：
-
 ```java
 class Solution {
     public int add(int a, int b) {
@@ -112,6 +110,17 @@ public:
 };
 ```
 
+### **Go**
+
+```go
+func add(a int, b int) int {
+	if b == 0 {
+		return a
+	}
+	return add(a^b, (a&b)<<1)
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -128,17 +137,6 @@ var add = function (a, b) {
 };
 ```
 
-### **Go**
-
-```go
-func add(a int, b int) int {
-	if b == 0 {
-		return a
-	}
-	return add(a^b, (a&b)<<1)
-}
-```
-
 ### **C#**
 
 ```cs

lcof/面试题68 - I. 二叉搜索树的最近公共祖先/README.md

@@ -42,16 +42,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-从上到下搜索，找到第一个值位于 `[p, q]` 之间的结点即可。既可以用迭代实现，也可以用递归实现。
+**方法一：一次遍历**
+
+从上到下遍历二叉树，找到第一个值位于 $[p.val,.. q.val]$ 之间的结点即可。既可以用迭代实现，也可以用递归实现。
+
+时间复杂度 $O(n)$，其中 $n$ 是二叉树的结点数。空间复杂度方面，迭代实现的空间复杂度为 $O(1)$，递归实现的空间复杂度为 $O(n)$。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-#### 迭代法
-
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -65,9 +67,7 @@ class Solution:
     def lowestCommonAncestor(
         self, root: TreeNode, p: TreeNode, q: TreeNode
     ) -> TreeNode:
-        if p == q:
-            return p
-        while root:
+        while 1:
             if root.val < p.val and root.val < q.val:
                 root = root.right
             elif root.val > p.val and root.val > q.val:
@@ -76,8 +76,6 @@ class Solution:
                 return root
 ```
 
-#### 递归法
-
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -111,10 +109,7 @@ class Solution:
  */
 class Solution {
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-        if (p == q) {
-            return p;
-        }
-        while (root != null) {
+        while (true) {
             if (root.val < p.val && root.val < q.val) {
                 root = root.right;
             } else if (root.val > p.val && root.val > q.val) {
@@ -123,11 +118,131 @@ class Solution {
                 return root;
             }
         }
-        return null;
     }
 }
 ```
 
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode 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);
+        }
+        return root;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* 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);
+        }
+        return root;
+    }
+};
+```
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        while (1) {
+            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;
+            }
+        }
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val   int
+ *     Left  *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	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
+}
+```
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val   int
+ *     Left  *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	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
+		}
+	}
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -145,8 +260,6 @@ class Solution {
  * @return {TreeNode}
  */
 var lowestCommonAncestor = function (root, p, q) {
-    // 递归
-    if (!root) return null;
     if (root.val < p.val && root.val < q.val) {
         return lowestCommonAncestor(root.right, p, q);
     } else if (root.val > p.val && root.val > q.val) {
@@ -158,8 +271,6 @@ var lowestCommonAncestor = function (root, p, q) {
 
 ### **TypeScript**
 
-递归：
-
 ```ts
 /**
  * Definition for a binary tree node.
@@ -192,8 +303,6 @@ function lowestCommonAncestor(
 }
 ```
 
-循环：
-
 ```ts
 /**
  * Definition for a binary tree node.

lcof/面试题68 - I. 二叉搜索树的最近公共祖先/Solution.cpp

@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* 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);
+        }
+        return root;
+    }
+};

lcof/面试题68 - I. 二叉搜索树的最近公共祖先/Solution.go

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val   int
+ *     Left  *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	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
+}

lcof/面试题68 - I. 二叉搜索树的最近公共祖先/Solution.js

@@ -12,8 +12,6 @@
  * @return {TreeNode}
  */
 var lowestCommonAncestor = function (root, p, q) {
-    // 递归
-    if (!root) return null;
     if (root.val < p.val && root.val < q.val) {
         return lowestCommonAncestor(root.right, p, q);
     } else if (root.val > p.val && root.val > q.val) {

lcof/面试题68 - I. 二叉搜索树的最近公共祖先/Solution.py

@@ -10,9 +10,7 @@ class Solution:
     def lowestCommonAncestor(
         self, root: TreeNode, p: TreeNode, q: TreeNode
     ) -> TreeNode:
-        if p == q:
-            return p
-        while root:
+        while 1:
             if root.val < p.val and root.val < q.val:
                 root = root.right
             elif root.val > p.val and root.val > q.val:

lcof/面试题68 - II. 二叉树的最近公共祖先/README.md

@@ -43,18 +43,22 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-根据“**最近公共祖先**”的定义，若 root 是 p, q 的最近公共祖先 ，则只可能为以下情况之一：
+**方法一：递归**
 
--   如果 p 和 q 分别是 root 的左右节点，那么 root 就是我们要找的最近公共祖先；
--   如果 p 和 q 都是 root 的左节点，那么返回 `lowestCommonAncestor(root.left, p, q)`；
--   如果 p 和 q 都是 root 的右节点，那么返回 `lowestCommonAncestor(root.right, p, q)`。
+根据“**最近公共祖先**”的定义，若 $root$ 是 $p$, $q$ 的最近公共祖先，则只可能为以下情况之一：
+
+-   如果 $p$ 和 $q$ 分别是 $root$ 的左右节点，那么 $root$ 就是我们要找的最近公共祖先；
+-   如果 $p$ 和 $q$ 都是 $root$ 的左节点，那么返回 $lowestCommonAncestor(root.left, p, q)$；
+-   如果 $p$ 和 $q$ 都是 $root$ 的右节点，那么返回 $lowestCommonAncestor(root.right, p, q)$。
 
 **边界条件讨论**：
 
--   如果 root 为 null，则说明我们已经找到最底了，返回 null 表示没找到；
--   如果 root 与 p 相等或者与 q 相等，则返回 root；
--   如果左子树没找到，递归函数返回 null，证明 p 和 q 同在 root 的右侧，那么最终的公共祖先就是右子树找到的结点；
--   如果右子树没找到，递归函数返回 null，证明 p 和 q 同在 root 的左侧，那么最终的公共祖先就是左子树找到的结点。
+-   如果 $root$ 为 `null`，则说明我们已经找到最底了，返回 `null` 表示没找到；
+-   如果 $root$ 与 $p$ 相等或者与 $q$ 相等，则返回 $root$；
+-   如果左子树没找到，递归函数返回 `null`，证明 $p$ 和 $q$ 同在 $root$ 的右侧，那么最终的公共祖先就是右子树找到的结点；
+-   如果右子树没找到，递归函数返回 `null`，证明 $p$ 和 $q$ 同在 $root$ 的左侧，那么最终的公共祖先就是左子树找到的结点。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
 
 <!-- tabs:start -->