1.设计程序，利用二叉链表结构，建立一棵二叉树。并能递归实现二叉树的先序遍历、中序遍历和后序遍历三种遍历算法，能用队列实现二叉树的层次遍历算法，并按层次输出（标出层号），并能统计树叶数，结点数，层高等

非常感谢您的提问！

针对您的问题，我可以给出一下思路和代码供您参考：

首先，我们可以定义一个节点类，表示二叉树的节点：

class TreeNode {
public:
    TreeNode(int _val): val(_val), left(nullptr), right(nullptr) {}
    int val;
    TreeNode* left;
    TreeNode* right;
};

然后，我们可以定义一个二叉树类，包含节点插入、递归遍历、非递归遍历和统计树叶数、结点数、层高的方法：

class BinaryTree {
public:
    BinaryTree(): root(nullptr) {}

    // 插入节点
    void insert(int val);

    // 递归遍历
    void preorder_traversal(TreeNode* node);
    void inorder_traversal(TreeNode* node);
    void postorder_traversal(TreeNode* node);

    // 非递归遍历
    void levelorder_traversal();

    // 统计信息
    int get_leaf_count();
    int get_node_count();
    int get_height();

private:
    TreeNode* root;
    int leaf_count;
    int node_count;
    int height;

    // 内部方法
    void preorder_traversal_helper(TreeNode* node);
    void inorder_traversal_helper(TreeNode* node);
    void postorder_traversal_helper(TreeNode* node);
};

插入节点实现方式如下：

void BinaryTree::insert(int val) {
    TreeNode** cur = &root;
    while (*cur != nullptr) {
        if (val < (*cur)->val) {
            cur = &((*cur)->left);
        } else {
            cur = &((*cur)->right);
        }
    }
    *cur = new TreeNode(val);
}

递归遍历实现方式如下：

void BinaryTree::preorder_traversal(TreeNode* node) {
    preorder_traversal_helper(node);
}

void BinaryTree::preorder_traversal_helper(TreeNode* node) {
    if (node == nullptr) {
        return;
    }
    // 处理节点
    // ...

    // 遍历左子树
    preorder_traversal_helper(node->left);

    // 遍历右子树
    preorder_traversal_helper(node->right);
}

非递归遍历实现方式如下：

void BinaryTree::levelorder_traversal() {
    if (root == nullptr) {
        return;
    }

    std::queue<TreeNode*> q;
    q.push(root);
    int level = 1;

    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            TreeNode* cur = q.front();
            q.pop();

            // 处理节点
            // ...

            if (cur->left != nullptr) {
                q.push(cur->left);
            }

            if (cur->right != nullptr) {
                q.push(cur->right);
            }
        }
        // 输出层级
        // ...
        level++;
    }
}

统计信息实现方式如下：

int BinaryTree::get_leaf_count() {
    leaf_count = 0;
    std::function<void(TreeNode*)> dfs = [&](TreeNode* node) {
        if (node == nullptr) {
            return;
        }
        if (node->left == nullptr && node->right == nullptr) {
            leaf_count++;
            return;
        }
        dfs(node->left);
        dfs(node->right);
    };
    dfs(root);
    return leaf_count;
}

int BinaryTree::get_node_count() {
    node_count = 0;
    std::function<void(TreeNode*)> dfs = [&](TreeNode* node) {
        if (node == nullptr) {
            return;
        }
        node_count++;
        dfs(node->left);
        dfs(node->right);
    };
    dfs(root);
    return node_count;
}

int BinaryTree::get_height() {
    height = 0;
    std::function<void(TreeNode*, int)> dfs = [&](TreeNode* node, int level) {
        if (node == nullptr) {
            return;
        }
        height = std::max(height, level);
        dfs(node->left, level + 1);
        dfs(node->right, level + 1);
    };
    dfs(root, 1);
    return height;
}

以上是我对于您的问题的回答，希望能够帮助您解决问题，如果还有什么不清楚的，请随时提出。