编写二叉树的递归遍历程序,实现:给定一棵二叉树的“扩展先序遍历序列”,创建这棵 二叉树 (1)输出二叉树的先序遍历的结点序列。 (2)输出二叉树的后序遍历的结点序列。 (3)输出二叉树的中序遍历的结点序列。 (4)输出二叉树的叶子结点。 (5)统计二叉树的结点个数。

Hello！我可以回答你的问题。以下是二叉树的递归遍历程序：

给定一棵二叉树的扩展先序遍历序列，我们可以通过递归的方式创建这棵二叉树，代码实现如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return buildTreeHelper(preorder, inorder, 0, preorder.size()-1, 0, inorder.size()-1);
    }

    TreeNode* buildTreeHelper(vector<int>& preorder, vector<int>& inorder, 
        int pre_start, int pre_end, int in_start, int in_end)
    {
        if (pre_start > pre_end) {
            return nullptr;
        }
        int root_val = preorder[pre_start];
        TreeNode* root = new TreeNode(root_val);
        int root_pos = 0;
        for (int i=in_start; i<=in_end; i++) {
            if (inorder[i] == root_val) {
                root_pos = i;
                break;
            }
        }
        int left_count = root_pos - in_start;
        int right_count = in_end - root_pos;
        root->left = buildTreeHelper(preorder, inorder, pre_start+1, pre_start+left_count, in_start, root_pos-1);
        root->right = buildTreeHelper(preorder, inorder, pre_end-right_count+1, pre_end, root_pos+1, in_end);
        return root;
    }
};

其中，变量`pre_start`, `pre_end`, `in_start`, `in_end`表示当前二叉树子树在先序和中序遍历中的区间范围。

(1)输出二叉树的先序遍历的结点序列：

先序遍历的顺序是：根节点 -> 左子树 -> 右子树。所以我们只需要按照这个顺序递归遍历每个节点，输出它们的值即可。代码实现如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        preorderTraversalHelper(root, ret);
        return ret;
    }

    void preorderTraversalHelper(TreeNode* root, vector<int>& ret) {
        if (root == nullptr) {
            return;
        }
        ret.push_back(root->val);
        preorderTraversalHelper(root->left, ret);
        preorderTraversalHelper(root->right, ret);
    }
};

(2)输出二叉树的后序遍历的结点序列：

后序遍历的顺序是：左子树 -> 右子树 -> 根节点。所以我们只需要按照这个顺序递归遍历每个节点，输出它们的值即可。代码实现如下：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        postorderTraversalHelper(root, ret);
        return ret;
    }

    void postorderTraversalHelper(TreeNode* root, vector<int>& ret) {
        if (root == nullptr) {
            return;
        }
        postorderTraversalHelper(root->left, ret);
        postorderTraversalHelper(root->right, ret);
        ret.push_back(root->val);
    }
};

(3)输出二叉树的中序遍历的结点序列：

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。所以我们只需要按照这个顺序递归遍历每个节点，输出它们的值即可。代码实现如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        inorderTraversalHelper(root, ret);
        return ret;
    }

    void inorderTraversalHelper(TreeNode* root, vector<int>& ret) {
        if (root == nullptr) {
            return;
        }
        inorderTraversalHelper(root->left, ret);
        ret.push_back(root->val);
        inorderTraversalHelper(root->right, ret);
    }
};

(4)输出二叉树的叶子结点：

如果一个节点的左子树和右子树都为空，那么它就是叶子节点。我们可以通过递归遍历每个节点，判断是否为叶子节点，如果是叶子节点，就输出它的值。代码实现如下：

class Solution {
public:
    vector<int> getLeaves(TreeNode* root) {
        vector<int> ret;
        getLeavesHelper(root, ret);
        return ret;
    }

    void getLeavesHelper(TreeNode* root, vector<int>& ret) {
        if (root == nullptr) {
            return;
        }
        if (root->left == nullptr && root->right == nullptr) {
            ret.push_back(root->val);
        }
        getLeavesHelper(root->left, ret);
        getLeavesHelper(root->right, ret);
    }
};

(5)统计二叉树的结点个数：

我们可以通过递归遍历每个节点，依次累加它们的数量，最终得到二叉树的结点个数。代码实现如下：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

以上是关于二叉树的递归遍历程序的实现，希望回答能够帮到你！