对于给定的二叉树，输出其先序序列、中序序列、后序序列并输出叶子结点数

为了输出给定二叉树的先序序列、中序序列、后序序列，可以使用递归的方法来遍历整个二叉树。具体步骤如下：

1. 先输出当前节点的值，即先序序列。

2. 如果当前节点有左子树，则递归遍历左子树。

3. 输出当前节点的值，即中序序列。

4. 如果当前节点有右子树，则递归遍历右子树。

5. 输出当前节点的值，即后序序列。

输出叶子结点数可以在遍历二叉树的过程中进行统计。具体步骤如下：

1. 如果当前节点是叶子结点，则将叶子结点数加1。

2. 如果当前节点有左子树，则递归遍历左子树。

3. 如果当前节点有右子树，则递归遍历右子树。

最终输出先序序列、中序序列、后序序列和叶子结点数即可。

相关问题

【二叉树】先序序列创建二叉树，输出先序序列、中序序列、后序序列并输出叶子结点数 （java） 代码

在Java中，我们可以使用递归的方式来创建二叉树并生成其先序、中序和后序序列。下面是一个简单的示例代码，它首先定义了一个二叉树节点类`TreeNode`，然后提供了一个函数`buildTreePreInPost`来构建树并获取序列：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTree {
    public static void main(String[] args) {
        // 先序序列示例 [1, 2, 4, 7, 3, 6, 5]
        int[] preOrder = {1, 2, 4, 7, 3, 6, 5};
        TreeNode root = buildTreePreInPost(preOrder, 0);

        // 输出先序、中序和后序序列
        System.out.println("先序遍历: " + printPreOrder(root));
        System.out.println("中序遍历: " + printInOrder(root));
        System.out.println("后序遍历: " + printPostOrder(root));

        // 计算叶子节点数
        int leafCount = countLeaves(root);
        System.out.println("叶子节点数: " + leafCount);
    }

    public static TreeNode buildTreePreInPost(int[] preorder, int index) {
        if (index == preorder.length) return null;
        TreeNode node = new TreeNode(preorder[index]);
        int i = findInPostIndex(preorder, index);
        node.left = buildTreePreInPost(preorder, index + 1); // 左孩子
        node.right = buildTreePreInPost(preorder, i);     // 右孩子
        return node;
    }

    private static int findInPostIndex(int[] inorder, int preorderIndex) {
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == preorder[preorderIndex]) {
                return i + 1; // 中序下标从1开始
            }
        }
        return -1;
    }

    // 递归遍历方法
    private static String printPreOrder(TreeNode node) {
        if (node == null) return "";
        return node.val + " " + printPreOrder(node.left) + printPreOrder(node.right);
    }

    private static String printInOrder(TreeNode node) {
        if (node == null) return "";
        return printInOrder(node.left) + node.val + " " + printInOrder(node.right);
    }

    private static String printPostOrder(TreeNode node) {
        if (node == null) return "";
        return printPostOrder(node.left) + printPostOrder(node.right) + node.val;
    }

    private static int countLeaves(TreeNode node) {
        if (node == null) return 0;
        if (node.left == null && node.right == null) return 1; // 如果左右都是null，则是叶子节点
        return countLeaves(node.left) + countLeaves(node.right);
    }
}

这个程序首先根据给定的先序遍历序列构建了二叉树，然后分别计算并输出了三种遍历序列以及叶子节点的数量。

编写二叉树的递归遍历算法，给定二叉树的扩展先序遍历序列，输出二叉树的先序遍历，中序遍历和后序遍历的结点序列和叶子结点和和结点个数的c语言代码

以下是对应的 C 语言代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建一棵二叉树
TreeNode* createTree(int* pos) {
    char* s = "AB##C##";
    char ch = s[(*pos)++];
    if (ch == '#') {
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = ch;
    root->left = createTree(pos);
    root->right = createTree(pos);
    return root;
}

// 先序遍历
void preOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%c ", root->val);
    preOrder(root->left);
    preOrder(root->right);
}

// 中序遍历
void inOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inOrder(root->left);
    printf("%c ", root->val);
    inOrder(root->right);
}

// 后序遍历
void postOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postOrder(root->left);
    postOrder(root->right);
    printf("%c ", root->val);
}

// 计算叶子结点个数
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);
}

// 计算结点个数
int countNodes(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    return countNodes(root->left) + countNodes(root->right) + 1;
}

int main() {
    int pos = 0;
    TreeNode* root = createTree(&pos);

    printf("先序遍历：");
    preOrder(root);
    printf("\n");

    printf("中序遍历：");
    inOrder(root);
    printf("\n");

    printf("后序遍历：");
    postOrder(root);
    printf("\n");

    printf("叶子结点个数：%d\n", countLeaves(root));
    printf("结点个数：%d\n", countNodes(root));

    return 0;
}