数据结构 假设二叉树用二叉链表存储，设计一个算法，求二叉树的结点个数。

好的，以下是求二叉树结点个数的Python代码实现：

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

def count_nodes(root: TreeNode) -> int:
    if not root:
        return 0
    return 1 + count_nodes(root.left) + count_nodes(root.right)

其中 `TreeNode` 是二叉树结点的类，包含了结点的值以及左右子节点；`count_nodes` 是求二叉树结点个数的函数，采用递归的思想，不断累加左右子树结点个数，最后加上根节点，即为整个二叉树的结点个数。

希望这个代码能够帮助您解决问题，如果您还有其他问题，请随时提出。

相关问题

假设二叉树采用二叉链表存储结构存储。设计 一个算法按从左到右输出一棵二叉树中所有叶子结点值。写出二叉链表各个结点的类C语言描述。

当我们处理二叉树的链式存储结构时，每个节点通常包含三个部分：数据域用于存储节点的值，指向前驱节点的指针（left），以及指向后继节点的指针（right）。对于叶子节点（即没有子节点的节点），它们的right指针通常是NULL。以下是C语言中一个简单的二叉链表节点类的描述：

// 定义二叉链表节点结构体
typedef struct Node {
    int value;           // 节点值
    struct Node* left;   // 左子节点指针
    struct Node* right;  // 右子节点指针
} TreeNode;

// 插入函数，这里只关注插入叶子节点的情况
void insertAsLeaf(TreeNode** root, int value) {
    if (*root == NULL) {
        *root = (TreeNode*)malloc(sizeof(TreeNode));
        (*root)->value = value;
        (*root)->left = NULL;
        (*root)->right = NULL;
    } else {
        // 如果已有子节点，递归查找最后一个叶子节点并插入
        insertAsLeaf(&(*root)->right, value);
    }
}

// 遍历左子树并打印叶子节点
void printLeavesRecursively(TreeNode* node, bool isVisited[]) {
    if (node == NULL || isVisited[node] == true) return;
    
    isVisited[node] = true;
    if (node->left == NULL && node->right == NULL) { // 判断是否为叶子节点
        printf("%d ", node->value); // 打印节点值
    }
    printLeavesRecursively(node->left, isVisited);
    printLeavesRecursively(node->right, isVisited);
}

// 主函数示例，创建一个空树然后插入叶子节点，并遍历输出
int main() {
    TreeNode* root = NULL;
    insertAsLeaf(&root, 1); // 插入节点1作为根节点
    // ... 接着可以继续插入其他叶子节点
    
    int visited[1000]; // 假设我们假设最大有1000个节点
    for (int i = 0; i < 1000; i++) {
        visited[i] = false;
    }
    
    printLeavesRecursively(root, visited);
    return 0;
}

1.设二叉树采用二叉链表存储，编写函数，对二叉树中每个元素值为X的结点，删除以它为根的子树，并释放相应空间。 2.假设二叉树采用二叉链表存储结构，求二叉树b中结点值为x的结点的层次（或深度）

1. 要编写一个删除二叉树中所有值为 X 的节点的函数，首先需要遍历整个二叉链表树结构。这个过程可以递归地完成，从根节点开始搜索：

def delete_nodes(root, value):
    if not root:
        return None
    
    # 如果当前节点就是要删除的节点，替换为NULL
    if root.value == value:
        root = None
    else:
        # 递归处理左子树和右子树
        root.left = delete_nodes(root.left, value)
        root.right = delete_nodes(root.right, value)

    return root

然后，对于释放空间的问题，由于二叉链表的节点通常包含指向前驱和后继节点的引用，所以在删除节点后，记得将它们的前驱或后继指向NULL，避免形成悬挂指针。

2. 求解二叉树中结点值为 x 的节点的层次，我们可以使用队列辅助的广度优先搜索（BFS）算法：

def get_depth(node, target_value, current_level=0):
    if not node:
        return -1

    if node.value == target_value:
        return current_level

    left_depth = get_depth(node.left, target_value, current_level + 1)
    right_depth = get_depth(node.right, target_value, current_level + 1)

    return max(left_depth, right_depth) if left_depth != -1 or right_depth != -1 else -1

# 使用时，传入二叉树的根节点和目标值即可
depth = get_depth(binary_tree_root, x)