设计算法CountNode统计二叉树T中结点数据域值是偶数的结点总数，无返回值，用c或c++

以下是C++实现：

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void CountNode(TreeNode* root, int& count) {
    if (root == nullptr) {  // 空结点直接返回
        return;
    }
    if (root->val % 2 == 0) {  // 如果当前结点的数据域值为偶数，计数器加一
        count++;
    }
    CountNode(root->left, count);   // 递归遍历左子树
    CountNode(root->right, count);  // 递归遍历右子树
}

其中，`CountNode`函数接受二叉树根结点指针和计数器`count`的引用作为参数，通过引用传递的方式实现计数器值的修改。在函数内部，先判断当前结点是否为空，如果为空直接返回；否则如果当前结点的数据域值为偶数，计数器加一。然后递归遍历左子树和右子树。最后，调用`CountNode`函数即可统计二叉树中结点数据域值是偶数的结点总数，计数器的值即为所求。

相关问题

统计二叉树中结点数据域值是偶数的结点数的算法

可以采用递归的方式遍历整棵二叉树，在遍历过程中统计数据域值为偶数的结点数量。具体算法步骤如下：

1. 如果当前结点为空，则返回 0。

2. 统计当前结点的数据域值是否为偶数，如果是，则计数器加一。

3. 递归遍历当前结点的左子树，统计其中数据域值为偶数的结点数量。

4. 递归遍历当前结点的右子树，统计其中数据域值为偶数的结点数量。

5. 返回当前结点及其子树中数据域值为偶数的结点数量之和。

以下是该算法的 Python 代码实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def count_even_nodes(root):
    if not root:
        return 0

    count = 1 if root.val % 2 == 0 else 0
    count += count_even_nodes(root.left)
    count += count_even_nodes(root.right)

    return count

# 示例用法
root = Node(2)
root.left = Node(1)
root.right = Node(4)
root.right.left = Node(3)
root.right.right = Node(6)

count = count_even_nodes(root)
print(count)  # 输出 3

帮我编写一个程序，内容如下 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