0222.-完全二叉树的节点个数

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：

输入：root = [1,2,3,4,5,6]
输出：6
示例 2：

输入：root = []
输出：0
示例 3：

输入：root = [1]
输出：1

提示：

树中节点的数目范围是[0, 5 * 104]
0 <= Node.val <= 5 * 104
题目数据保证输入的树是 完全二叉树

进阶：遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-complete-tree-nodes

python

# 0222.完全二叉树的节点个数
class Solution:
    # 递归法
    def countNodes(self, root: TreeNode) -> int:
        def getNodesNum(node):
            if not node:
                return 0
            leftNum = getNodesNum(node.left)
            rightNum = getNodesNum(node.right)
            nodesNum = leftNum + rightNum + 1
            return nodesNum
        return getNodesNum(root)

    # 迭代法-层序遍历
    def countNodes1(self, root: TreeNode) -> int:
        from collections import deque
        queue = deque()
        if root:
            queue.append(root)
        nums = 0
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                nums += 1
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return nums

    # 递归法-完全二叉树版本
    def countNodes2(self, root: TreeNode) -> int:
        if not root:
            return 0
        left = root.left
        right = root.right
        # 左右子树高度初始化为0,
        leftHeight = 0
        rightHeight = 0
        # 左子树深度
        while left:
            left = left.left
            leftHeight += 1
        # 右子树深度
        while right:
            right = right.right
            rightHeight += 1
        if leftHeight == rightHeight:
            return (2 << leftHeight)-1 # 2<<1 = 2^2 = 4, 非空时，height=1
        return self.countNodes2(root.left) + self.countNodes2(root.right) + 1

golang

package binaryTree

import "container/list"

// 迭代遍历
func countNodes1(root *TreeNode) int {
	if root == nil { // 空时返回
		return 0
	}
	nums := 1
	queue := list.New() // 队列控制层序遍历
	queue.PushBack(root)
	for queue.Len() > 0 {
		length := queue.Len()
		for i:=0;i<length;i++ { // 遍历当层的节点
			node := queue.Remove(queue.Front()).(*TreeNode) // 当次节点
			nums++
			if node.Left != nil { // 节点的左节点入队
				queue.PushBack(node.Left)
			}
			if node.Right != nil { // 节点的右节点入队
				queue.PushBack(node.Right)
			}
		}
	}
	return nums
}

// 递归-一般二叉树
func countNodes2(root *TreeNode) int {
	if root == nil {
		return 0
	}
	res := 1
	if root.Right != nil {
		res += countNodes2(root.Right)
	}
	if root.Left != nil {
		res += countNodes2(root.Left)
	}
	return res
}

// 递归-完全二叉树
func countNodes3(root *TreeNode) int {
	if root == nil {
		return 0
	}
	leftH, rightH := 0, 0
	leftNode := root.Left
	rightNode := root.Right
	for leftNode != nil {
		leftNode = leftNode.Left
		leftH++
	}
	for rightNode != nil {
		rightNode = rightNode.Right
		rightH++
	}
	if leftH == rightH {
		return (2 << leftH) - 1
	}
	return countNodes3(root.Left) + countNodes3(root.Right) + 1
}