计算二叉树的节点总数和深度

计算二叉树节点总数可以使用递归的方法，先计算左子树和右子树的节点总数，再加上根节点的1即可。代码如下：

int countNodes(TreeNode* root) {
    if (!root) return 0;
    return 1 + countNodes(root->left) + countNodes(root->right);
}

计算二叉树深度也可以使用递归的方法，先计算左子树和右子树的深度，再加上根节点的1取最大值即可。代码如下：

int maxDepth(TreeNode* root) {
    if (!root) return 0;
    return 1 + max(maxDepth(root->left), maxDepth(root->right));
}

其中 `TreeNode` 是二叉树节点的结构体，包含 `left` 和 `right` 两个指针分别指向左右子树。

相关问题

python实现1。先按先序遍历序列建立二叉树的二叉链表； 2.用递归方式实现以下操作： 1)计算二叉树结点总数 2)计算二叉树深度 3)计算二叉树叶子结点总数 4)交换二叉树每个结点的左孩子和右孩子。

好的，我知道了。对于你的问题，我可以给你以下 Python 代码实现：

# 定义二叉树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 按先序遍历序列建立二叉树的二叉链表
def buildTree(preorder):
    if not preorder:
        return None

    root = TreeNode(preorder[0])
    idx = 1
    while idx < len(preorder) and preorder[idx] <= preorder[0]:
        idx += 1

    root.left = buildTree(preorder[1:idx])
    root.right = buildTree(preorder[idx:])

    return root

# 计算二叉树结点总数
def countNodes(root):
    if not root:
        return 0

    return 1 + countNodes(root.left) + countNodes(root.right)

# 计算二叉树深度
def maxDepth(root):
    if not root:
        return 0

    return 1 + max(maxDepth(root.left), maxDepth(root.right))

# 计算二叉树叶子结点总数
def countLeaves(root):
    if not root:
        return 0

    if not root.left and not root.right:
        return 1

    return countLeaves(root.left) + countLeaves(root.right)

# 交换二叉树每个结点的左孩子和右孩子
def swapNodes(root):
    if not root:
        return

    root.left, root.right = root.right, root.left

    swapNodes(root.left)
    swapNodes(root.right)

希望这个代码可以解决你的问题。如果你有其他问题，随时问我哦。

求二叉树中叶结点的个数、二叉树结点总数以及二叉树的深度。

### 回答1：
二叉树中叶结点的个数是指没有子节点的节点个数，可以通过遍历整个二叉树，统计叶节点的个数来得到。

二叉树结点总数是指整个二叉树中节点的总个数，可以通过遍历整个二叉树，统计节点的个数来得到。

二叉树的深度是指从根节点到最深叶节点的路径长度，可以通过递归遍历二叉树，每次记录当前节点的深度，最终得到最大深度来得到。

### 回答2：
二叉树是一种重要的树形数据结构，其中每个节点最多只有两个子节点，分别为左子节点和右子节点。二叉树可以用来存储和管理各种数据信息，如文件系统、数据库索引等。在二叉树中，叶节点是指没有子节点的节点，二叉树的深度是指从根节点到某个叶节点的最长路径长度。

要求二叉树中叶节点的个数，可以采用遍历二叉树的方法，将每个节点都进行判断，若该节点没有左右子节点，则该节点就是叶节点。可以使用递归的方式实现代码，从根节点开始遍历，当遇到叶节点时，将叶节点的个数加1。遍历完成后，即可得到二叉树中叶节点的个数。

要求二叉树结点总数，也可以采用递归的方法，从根节点开始，每个节点的总数等于左子树节点的总数加上右子树节点的总数再加上1（当前节点）。因此可以递归地计算下去，直到叶节点，这时候总数为1。最后将每个节点计数相加即可得到二叉树的结点总数。

要求二叉树的深度，同样可以采用递归的方法来实现。以该节点为根的深度等于其左子树的深度与右子树的深度之间的较大值再加上1。因此可以递归地计算下去，直到叶节点，这时候深度为1。最后将每个节点的深度计算出来，取其中的最大值即可得到二叉树的深度。

### 回答3：
二叉树是一种经典的树形数据结构，由根节点和两个子树组成，其中子树本身也是一棵二叉树。在二叉树中，叶子节点是没有子节点的节点，而非叶节点是至少有一个子节点的节点。求二叉树中的叶子节点数量、节点总数和深度是二叉树相关问题中的常见问题。

首先，要求二叉树中的叶子节点数量。我们可以通过递归遍历所有子树，找出叶子节点并计数。以下是求二叉树叶子节点个数的代码：

int countLeafNodes(BinaryTree tree) {
    if (tree == null) {
        return 0;
    }
    if (tree.left == null && tree.right == null) {
        return 1;
    }
    return countLeafNodes(tree.left) + countLeafNodes(tree.right);
}

在上述代码中，我们采用递归方式遍历二叉树。如果节点为空，说明该子树中没有节点，返回零；否则，如果该节点没有左右子树，说明该节点为叶子节点，返回1；最后，递归遍历左右子树，统计叶子节点个数并返回。

其次，要求二叉树结点总数。同样采用递归遍历的方式，统计每个节点出现的次数。以下是求二叉树节点总数的代码：

int countNodes(BinaryTree tree) {
    if (tree == null) {
        return 0;
    }
    return countNodes(tree.left) + countNodes(tree.right) + 1;
}

在上述代码中，我们采用递归方式遍历二叉树。如果节点为空，说明该子树中没有节点，返回零；否则，递归遍历左右子树，并将其节点总数相加，再加上当前节点，即为整棵二叉树的节点总数。

最后，要求二叉树的深度。在二叉树中，深度也称为高度，是从根节点到最底层节点的最长路径的长度。我们同样采用递归的方式遍历二叉树，求出左右子树的深度，然后取最大值加1即可。以下是求二叉树深度的代码：

int getTreeDepth(BinaryTree tree) {
    if (tree == null) {
        return 0;
    }
    int leftDepth = getTreeDepth(tree.left);
    int rightDepth = getTreeDepth(tree.right);
    return Math.max(leftDepth, rightDepth) + 1;
}

在上述代码中，我们采用递归方式遍历二叉树。如果节点为空，说明该子树中没有节点，返回零；否则，递归计算左右子树的深度，取最大值并加上1，即为该节点所在子树的深度。整棵二叉树的深度即为根节点的深度。