feat: add solutions to lc problem: No.0222

No.0222.Count Complete Tree Nodes

Author: yanglbme

solution/0200-0299/0222.Count Complete Tree Nodes/README.md

@@ -51,18 +51,24 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-朴素解法是直接遍历整棵完全二叉树，统计结点个数。时间复杂度 $O(n)$。
+**方法一：递归**
+
+递归遍历整棵树，统计结点个数。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为树的结点个数。
+
+**方法二：二分查找**
 
 对于此题，我们还可以利用完全二叉树的特点，设计一个更快的算法。
 
 完全二叉树的特点：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。需要注意的是，满二叉树肯定是完全二叉树，而完全二叉树不一定是满二叉树。
 
-若满二叉树的层数为 h，则总结点数为 `2^h - 1`。
+若满二叉树的层数为 $h$，则总结点数为 $2^h - 1$。
 
-我们可以先对 root 的左右子树进行高度统计，分别记为 left, right。
+我们可以先对 $root$ 的左右子树进行高度统计，分别记为 $left$ 和 $right$。
 
-1.  若 `left == right`，说明左子树是一颗满二叉树。所以左子树的结点总数为 `2^left - 1`，加上 root 结点，就是 `2^left`，然后递归统计右子树即可。
-1.  若 `left > right`，说明右子树是一个满二叉树。所以右子树的结点总数为 `2^right - 1`，加上 root 结点，就是 `2^right`，然后递归统计左子树即可。
+1.  若 $left = right$，说明左子树是一颗满二叉树，那么左子树的结点总数为 $2^{left} - 1$，加上 $root$ 结点，就是 $2^{left}$，然后递归统计右子树即可。
+1.  若 $left > right$，说明右子树是一个满二叉树，那么右子树的结点总数为 $2^{right} - 1$，加上 $root$ 结点，就是 $2^{right}$，然后递归统计左子树即可。
 
 时间复杂度 $O(\log^2 n)$。
 
@@ -80,14 +86,28 @@
 #         self.left = left
 #         self.right = right
 class Solution:
-    def countNodes(self, root: TreeNode) -> int:
+    def countNodes(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+        return 1 + self.countNodes(root.left) + self.countNodes(root.right)
+```
+
+```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 countNodes(self, root: Optional[TreeNode]) -> int:
         def depth(root):
-            res = 0
+            d = 0
             while root:
-                res += 1
+                d += 1
                 root = root.left
-            return res
-
+            return d
+        
         if root is None:
             return 0
         left, right = depth(root.left), depth(root.right)
@@ -100,6 +120,32 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```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 int countNodes(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return 1 + countNodes(root.left) + countNodes(root.right);
+    }
+}
+```
+
 ```java
 /**
  * Definition for a binary tree node.
@@ -130,10 +176,11 @@ class Solution {
     }
 
     private int depth(TreeNode root) {
-        int res = 0;
-        for (; root != null; root = root.left, ++res)
-            ;
-        return res;
+        int d = 0;
+        for (; root != null; root = root.left) {
+            ++d;
+        }
+        return d;
     }
 }
 ```
@@ -155,18 +202,46 @@ class Solution {
 class Solution {
 public:
     int countNodes(TreeNode* root) {
-        if (!root) return 0;
+        if (!root) {
+            return 0;
+        }
+        return 1 + countNodes(root->left) + countNodes(root->right);
+    }
+};
+```
+
+```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:
+    int countNodes(TreeNode* root) {
+        if (!root) {
+            return 0;
+        }
         int left = depth(root->left);
         int right = depth(root->right);
-        if (left == right) return (1 << left) + countNodes(root->right);
+        if (left == right) {
+            return (1 << left) + countNodes(root->right);
+        }
         return (1 << right) + countNodes(root->left);
     }
 
     int depth(TreeNode* root) {
-        int res = 0;
-        for (; root != nullptr; ++res, root = root->left)
-            ;
-        return res;
+        int d = 0;
+        for (; root; root = root->left) {
+            ++d;
+        }
+        return d;
     }
 };
 ```
@@ -186,20 +261,36 @@ func countNodes(root *TreeNode) int {
 	if root == nil {
 		return 0
 	}
-	depth := func(root *TreeNode) int {
-		res := 0
-		for root != nil {
-			res++
-			root = root.Left
-		}
-		return res
+	return 1 + countNodes(root.Left) + countNodes(root.Right)
+}
+```
+
+```go
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func countNodes(root *TreeNode) int {
+	if root == nil {
+		return 0
 	}
 	left, right := depth(root.Left), depth(root.Right)
 	if left == right {
 		return (1 << left) + countNodes(root.Right)
 	}
 	return (1 << right) + countNodes(root.Left)
 }
+
+func depth(root *TreeNode) (d int) {
+	for ; root != nil; root = root.Left {
+		d++
+	}
+	return
+}
 ```
 
 ### **JavaScript**
@@ -218,12 +309,37 @@ func countNodes(root *TreeNode) int {
  * @return {number}
  */
 var countNodes = function (root) {
-    if (!root) return 0;
-    let depth = function (root) {
-        let res = 0;
-        for (; root != null; ++res, root = root.left);
-        return res;
+    if (!root) {
+        return 0;
+    }
+    return 1 + countNodes(root.left) + countNodes(root.right);
+};
+```
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var countNodes = function (root) {
+    const depth = root => {
+        let d = 0;
+        for (; root; root = root.left) {
+            ++d;
+        }
+        return d;
     };
+    if (!root) {
+        return 0;
+    }
     const left = depth(root.left);
     const right = depth(root.right);
     if (left == right) {
@@ -251,23 +367,47 @@ var countNodes = function (root) {
  */
 public class Solution {
     public int CountNodes(TreeNode root) {
-        if (root == null)
-        {
+        if (root == null) {
+            return 0;
+        }
+        return 1 + CountNodes(root.left) + CountNodes(root.right);
+    }
+}
+```
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public int CountNodes(TreeNode root) {
+        if (root == null) {
             return 0;
         }
         int left = depth(root.left);
         int right = depth(root.right);
-        if (left == right)
-        {
+        if (left == right) {
             return (1 << left) + CountNodes(root.right);
         }
         return (1 << right) + CountNodes(root.left);
     }
 
     private int depth(TreeNode root) {
-        int res = 0;
-        for (; root != null; ++res, root = root.left);
-        return res;
+        int d = 0;
+        for (; root != null; root = root.left) {
+            ++d;
+        }
+        return d;
     }
 }
 ```