feat: update solutions to lcof problems: No.26,27,30 (doocs#2871)

Author: yanglbme

lcof/面试题26. 树的子结构/README.md

@@ -52,7 +52,19 @@ edit_url: https://github.com/doocs/leetcode/edit/main/lcof/%E9%9D%A2%E8%AF%95%E9
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：递归
+
+我们设计一个函数 $\text{dfs}(A, B)$，用于判断树 A 中以节点 A 为根节点的子树是否包含树 B。
+
+函数 $\text{dfs}(A, B)$ 的执行步骤如下：
+
+1. 如果树 B 为空，则树 B 是树 A 的子结构，返回 `true`；
+2. 如果树 A 为空，或者树 A 的根节点的值不等于树 B 的根节点的值，则树 B 不是树 A 的子结构，返回 `false`；
+3. 判断树 A 的左子树是否包含树 B，即调用 $\text{dfs}(A.left, B)$，并且判断树 A 的右子树是否包含树 B，即调用 $\text{dfs}(A.right, B)$。如果其中有一个函数返回 `false`，则树 B 不是树 A 的子结构，返回 `false`；否则，返回 `true`。
+
+在函数 `isSubStructure` 中，我们首先判断树 A 和树 B 是否为空，如果其中有一个为空，则树 B 不是树 A 的子结构，返回 `false`。然后，我们调用 $\text{dfs}(A, B)$，判断树 A 是否包含树 B。如果是，则返回 `true`；否则，递归判断树 A 的左子树是否包含树 B，以及树 A 的右子树是否包含树 B。如果其中有一个返回 `true`，则树 B 是树 A 的子结构，返回 `true`；否则，返回 `false`。
+
+时间复杂度 $O(n \times m)$，空间复杂度 $O(n)$。其中 $n$ 和 $m$ 分别是树 A 和树 B 的节点个数。
 
 <!-- tabs:start -->
 
@@ -130,13 +142,19 @@ class Solution {
 class Solution {
 public:
     bool isSubStructure(TreeNode* A, TreeNode* B) {
-        if (!A || !B) return 0;
+        if (!A || !B) {
+            return false;
+        }
         return dfs(A, B) || isSubStructure(A->left, B) || isSubStructure(A->right, B);
     }
 
     bool dfs(TreeNode* A, TreeNode* B) {
-        if (!B) return 1;
-        if (!A || A->val != B->val) return 0;
+        if (!B) {
+            return true;
+        }
+        if (!A || A->val != B->val) {
+            return false;
+        }
         return dfs(A->left, B->left) && dfs(A->right, B->right);
     }
 };

lcof/面试题26. 树的子结构/Solution.cpp

@@ -10,13 +10,19 @@
 class Solution {
 public:
     bool isSubStructure(TreeNode* A, TreeNode* B) {
-        if (!A || !B) return 0;
+        if (!A || !B) {
+            return false;
+        }
         return dfs(A, B) || isSubStructure(A->left, B) || isSubStructure(A->right, B);
     }
 
     bool dfs(TreeNode* A, TreeNode* B) {
-        if (!B) return 1;
-        if (!A || A->val != B->val) return 0;
+        if (!B) {
+            return true;
+        }
+        if (!A || A->val != B->val) {
+            return false;
+        }
         return dfs(A->left, B->left) && dfs(A->right, B->right);
     }
 };

lcof/面试题27. 二叉树的镜像/README.md

@@ -285,36 +285,4 @@ public class Solution {
 
 <!-- solution:end -->
 
-<!-- solution:start-->
-
-### 方法二
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, x):
-#         self.val = x
-#         self.left = None
-#         self.right = None
-
-
-class Solution:
-    def mirrorTree(self, root: TreeNode) -> TreeNode:
-        if root is None:
-            return root
-        left = self.mirrorTree(root.left)
-        right = self.mirrorTree(root.right)
-        root.left = right
-        root.right = left
-        return root
-```
-
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
 <!-- problem:end -->