数据结构以二叉链表作为二叉树的存储结构，编写以下算法：（1）统计二叉树的叶结点个数。

在数据结构中，二叉链表是一种常见的二叉树存储方式，每个节点通常包含两个指针，分别指向左孩子和右孩子。要统计二叉树的叶节点（即没有孩子的节点）个数，可以采用递归或迭代的方式来遍历整个二叉树。

这里提供一个使用递归的方法：

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

def count_leaves(node):
    # 如果节点为空，则返回0
    if node is None:
        return 0
    # 如果当前节点是叶子节点，返回1；否则，左右子树的叶节点之和
    elif node.left is None and node.right is None:
        return 1
    else:
        # 递归计算左子树和右子树的叶节点个数并相加
        return count_leaves(node.left) + count_leaves(node.right)

# 测试代码
root = Node(1, Node(2), Node(3, Node(4), Node(5)))
print(count_leaves(root))  # 输出：3（因为有3个叶节点：2, 4, 5）

相关问题

用数据结构算法：以二叉链表作为二叉树的存储结构，编写算法实现统计二叉树的叶结点个数

在使用二叉链表作为二叉树的存储结构时，统计叶节点个数的算法通常采用递归的方式。以下是Python的一个示例：

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

def count_leaves(root):
    if root is None:
        return 0   # 如果节点为空，返回0，表示没有叶节点
    elif root.left is None and root.right is None:  # 如果节点既是左孩子又是右孩子，说明它是叶子节点，计数加1
        return 1
    else:
        # 递归地对左右子树进行计数，然后相加得到当前节点的叶节点数目
        return count_leaves(root.left) + count_leaves(root.right)

# 示例
# 构建一棵简单的二叉树
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
# 现在可以调用count_leaves函数来获取叶节点的数量
leaf_count = count_leaves(root)
print("叶节点个数:", leaf_count)

以二叉链表作为二叉树的存储结构，编写以下算法： 统计二叉树的叶结点个数的编码、

以下是统计二叉树叶结点个数的算法的Python代码实现：

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

def count_leaf_nodes(root):
    if not root:
        return 0
    if not root.left and not root.right:
        return 1
    return count_leaf_nodes(root.left) + count_leaf_nodes(root.right)

# 测试代码
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(count_leaf_nodes(root)) # 输出 4

该算法的思路是，如果当前节点是空节点，那么返回0；如果当前节点是叶子节点（即左右子节点都为空），那么返回1；否则递归计算左右子树的叶子节点数量之和。时间复杂度为 $O(n)$，其中 $n$ 是二叉树的节点数。