二叉树深度的递归算法代码

二叉树的深度可以使用递归算法来求解。具体的算法如下：

1. 若根节点为空，则二叉树的深度为0。
2. 否则，分别递归求解左子树和右子树的深度，取两者中的最大值，然后加上1，即为二叉树的深度。

以下是递归算法的代码实现：

int depth(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }
    int left_depth = depth(root->left);
    int right_depth = depth(root->right);
    return max(left_depth, right_depth) + 1;
}

其中，TreeNode是二叉树节点的结构体，包含了左子树和右子树的指针。

相关问题

帮我编写一个程序，内容如下 1、先序遍历二叉树的递归算法 2、中序遍历二叉树的递归算法 3、后序遍历二叉树的递归算法 4、计算二叉树的深度的递归算法 5、统计二叉树的结点个数的递归算法 6、统计二叉树的叶子结点个数的递归算法 7、设计该二叉树第K层的结点个数。 8、求该二叉树中所有结点值最大的元素。 9、打印二叉树的叶子结点数的递归算法 给出完整的程序代码

好的，以下是您需要的程序代码：

# 定义二叉树的结构体
class TreeNode:
    def __init__(self, val=None, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 先序遍历二叉树的递归算法
def preorderTraversal(root):
    if not root:
        return
    print(root.val)
    preorderTraversal(root.left)
    preorderTraversal(root.right)

# 中序遍历二叉树的递归算法
def inorderTraversal(root):
    if not root:
        return
    inorderTraversal(root.left)
    print(root.val)
    inorderTraversal(root.right)

# 后序遍历二叉树的递归算法
def postorderTraversal(root):
    if not root:
        return
    postorderTraversal(root.left)
    postorderTraversal(root.right)
    print(root.val)

# 计算二叉树的深度的递归算法
def maxDepth(root):
    if not root:
        return 0
    left_depth = maxDepth(root.left)
    right_depth = maxDepth(root.right)
    return max(left_depth, right_depth) + 1

# 统计二叉树的结点个数的递归算法
def countNodes(root):
    if not root:
        return 0
    return countNodes(root.left) + countNodes(root.right) + 1

# 统计二叉树的叶子结点个数的递归算法
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)

# 设计该二叉树第K层的结点个数
def countNodesKthLevel(root, k):
    if not root:
        return 0
    if k == 1:
        return 1
    left_count = countNodesKthLevel(root.left, k - 1)
    right_count = countNodesKthLevel(root.right, k - 1)
    return left_count + right_count

# 求该二叉树中所有结点值最大的元素
def maxNodeValue(root):
    if not root:
        return float('-inf')
    left_max = maxNodeValue(root.left)
    right_max = maxNodeValue(root.right)
    return max(left_max, right_max, root.val)

# 打印二叉树的叶子结点数的递归算法
def printLeaves(root):
    if not root:
        return
    if not root.left and not root.right:
        print(root.val)
    printLeaves(root.left)
    printLeaves(root.right)

# 测试
if __name__ == '__main__':
    # 构建一个二叉树
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root.left.left = TreeNode(4)
    root.left.right = TreeNode(5)
    root.right.left = TreeNode(6)
    root.right.right = TreeNode(7)

    # 测试先序遍历
    print("先序遍历结果：")
    preorderTraversal(root)

    # 测试中序遍历
    print("中序遍历结果：")
    inorderTraversal(root)

    # 测试后序遍历
    print("后序遍历结果：")
    postorderTraversal(root)

    # 测试计算二叉树深度
    print("二叉树深度为：", maxDepth(root))

    # 测试统计二叉树结点个数
    print("二叉树结点个数为：", countNodes(root))

    # 测试统计二叉树叶子结点个数
    print("二叉树叶子结点个数为：", countLeaves(root))

    # 测试设计该二叉树第K层的结点个数
    k = 2
    print("二叉树第", k, "层的结点个数为：", countNodesKthLevel(root, k))

    # 测试求该二叉树中所有结点值最大的元素
    print("该二叉树中所有结点值最大的元素为：", maxNodeValue(root))

    # 测试打印二叉树的叶子结点数
    print("二叉树的叶子结点为：")
    printLeaves(root)

运行结果如下：

先序遍历结果：
1
2
4
5
3
6
7
中序遍历结果：
4
2
5
1
6
3
7
后序遍历结果：
4
5
2
6
7
3
1
二叉树深度为： 3
二叉树结点个数为： 7
二叉树叶子结点个数为： 4
二叉树第 2 层的结点个数为： 2
该二叉树中所有结点值最大的元素为： 7
二叉树的叶子结点为：
4
5
6
7

帮我编写一个程序，要求如下，给出完整定义的代码 1、先序遍历二叉树的递归算法 2、中序遍历二叉树的递归算法 3、后序遍历二叉树的递归算法 4、计算二叉树的深度的递归算法 5、统计二叉树的结点个数的递归算法 6、统计二叉树的叶子结点个数的递归算法 7、设计该二叉树第K层的结点个数。 8、求该二叉树中所有结点值最大的元素。 9、打印二叉树的叶子结点数的递归算法 给出完整的程序代码

好的，以下是完整的程序代码：

#include <iostream>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 先序遍历二叉树的递归算法
void preorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    cout << root->val << " ";
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

// 中序遍历二叉树的递归算法
void inorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    inorderTraversal(root->left);
    cout << root->val << " ";
    inorderTraversal(root->right);
}

// 后序遍历二叉树的递归算法
void postorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    cout << root->val << " ";
}

// 计算二叉树的深度的递归算法
int maxDepth(TreeNode* root) {
    if (root == NULL) return 0;
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return max(leftDepth, rightDepth) + 1;
}

// 统计二叉树的结点个数的递归算法
int countNodes(TreeNode* root) {
    if (root == NULL) return 0;
    return countNodes(root->left) + countNodes(root->right) + 1;
}

// 统计二叉树的叶子结点个数的递归算法
int countLeaves(TreeNode* root) {
    if (root == NULL) return 0;
    if (root->left == NULL && root->right == NULL) return 1;
    return countLeaves(root->left) + countLeaves(root->right);
}

// 设计该二叉树第K层的结点个数
int countNodesInKthLevel(TreeNode* root, int k) {
    if (root == NULL || k < 1) return 0;
    if (k == 1) return 1;
    return countNodesInKthLevel(root->left, k - 1) + countNodesInKthLevel(root->right, k - 1);
}

// 求该二叉树中所有结点值最大的元素
int findMax(TreeNode* root) {
    if (root == NULL) return INT_MIN;
    int leftMax = findMax(root->left);
    int rightMax = findMax(root->right);
    return max(root->val, max(leftMax, rightMax));
}

// 打印二叉树的叶子结点数的递归算法
void printLeaves(TreeNode* root) {
    if (root == NULL) return;
    if (root->left == NULL && root->right == NULL) cout << root->val << " ";
    printLeaves(root->left);
    printLeaves(root->right);
}

// 示例代码
int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    cout << "先序遍历：";
    preorderTraversal(root);
    cout << endl;

    cout << "中序遍历：";
    inorderTraversal(root);
    cout << endl;

    cout << "后序遍历：";
    postorderTraversal(root);
    cout << endl;

    cout << "深度为：" << maxDepth(root) << endl;

    cout << "结点个数为：" << countNodes(root) << endl;

    cout << "叶子结点个数为：" << countLeaves(root) << endl;

    cout << "第3层的结点个数为：" << countNodesInKthLevel(root, 3) << endl;

    cout << "节点值最大的元素为：" << findMax(root) << endl;

    cout << "叶子结点的值为：";
    printLeaves(root);
    cout << endl;

    return 0;
}

以上是完整的程序代码，你可以直接在 C++ 编译器中运行。注意要先定义二叉树节点的结构体 `TreeNode`，然后实现每个函数的具体逻辑。