1.以二叉链表表示二叉树，建立一棵二叉树。2.输出二叉树的中序遍历结果。3.输出二叉树的前序遍历结果。4.输出二叉树的后序遍历结果。5.计算二叉树的深度。6.统计二叉树的结点个数 。7.统计二叉树的叶结点个数。8.统计二叉树的度为1的结点个数。9.输出二叉树中从每个叶子结点到根结点的路径。

好的，下面是基于二叉链表表示二叉树的算法实现。假设二叉树的结点类型为：

struct BinaryTreeNode {
    int value;
    BinaryTreeNode* left;
    BinaryTreeNode* right;
};

其中，`value` 表示结点的值，`left` 和 `right` 分别表示结点的左右子树指针。下面是完整代码实现：

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

// 定义二叉树结点类型
struct BinaryTreeNode {
    int value;
    BinaryTreeNode* left;
    BinaryTreeNode* right;
};

// 创建一棵二叉树
BinaryTreeNode* createBinaryTree() {
    BinaryTreeNode* root = new BinaryTreeNode{1, nullptr, nullptr};
    root->left = new BinaryTreeNode{2, nullptr, nullptr};
    root->right = new BinaryTreeNode{3, nullptr, nullptr};
    root->left->left = new BinaryTreeNode{4, nullptr, nullptr};
    root->left->right = new BinaryTreeNode{5, nullptr, nullptr};
    root->right->left = new BinaryTreeNode{6, nullptr, nullptr};
    root->right->right = new BinaryTreeNode{7, nullptr, nullptr};
    return root;
}

// 中序遍历二叉树
void inorderTraversal(BinaryTreeNode* root) {
    stack<BinaryTreeNode*> s;
    BinaryTreeNode* p = root;
    while (p || !s.empty()) {
        if (p) {
            s.push(p);
            p = p->left;
        } else {
            p = s.top();
            s.pop();
            cout << p->value << " ";
            p = p->right;
        }
    }
}

// 前序遍历二叉树
void preorderTraversal(BinaryTreeNode* root) {
    stack<BinaryTreeNode*> s;
    BinaryTreeNode* p = root;
    while (p || !s.empty()) {
        if (p) {
            cout << p->value << " ";
            s.push(p);
            p = p->left;
        } else {
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
}

// 后序遍历二叉树
void postorderTraversal(BinaryTreeNode* root) {
    stack<BinaryTreeNode*> s;
    BinaryTreeNode* p = root;
    BinaryTreeNode* lastVisit = nullptr;
    while (p || !s.empty()) {
        if (p) {
            s.push(p);
            p = p->left;
        } else {
            BinaryTreeNode* topNode = s.top();
            if (topNode->right && topNode->right != lastVisit) {
                p = topNode->right;
            } else {
                cout << topNode->value << " ";
                lastVisit = topNode;
                s.pop();
            }
        }
    }
}

// 计算二叉树的深度
int depthOfBinaryTree(BinaryTreeNode* root) {
    if (!root) {
        return 0;
    }
    int leftDepth = depthOfBinaryTree(root->left);
    int rightDepth = depthOfBinaryTree(root->right);
    return max(leftDepth, rightDepth) + 1;
}

// 统计二叉树的结点个数
int countNodesOfBinaryTree(BinaryTreeNode* root) {
    if (!root) {
        return 0;
    }
    return countNodesOfBinaryTree(root->left) + countNodesOfBinaryTree(root->right) + 1;
}

// 统计二叉树的叶结点个数
int countLeafNodesOfBinaryTree(BinaryTreeNode* root) {
    if (!root) {
        return 0;
    }
    if (!root->left && !root->right) {
        return 1;
    }
    return countLeafNodesOfBinaryTree(root->left) + countLeafNodesOfBinaryTree(root->right);
}

// 统计二叉树的度为1的结点个数
int countNodesOfDegree1(BinaryTreeNode* root) {
    if (!root) {
        return 0;
    }
    int count = 0;
    if ((root->left && !root->right) || (!root->left && root->right)) {
        count = 1;
    }
    return count + countNodesOfDegree1(root->left) + countNodesOfDegree1(root->right);    
}

// 输出二叉树中从每个叶子结点到根结点的路径
void printAllPaths(BinaryTreeNode* root, vector<int>& path) {
    if (!root) {
        return;
    }
    path.push_back(root->value);
    if (!root->left && !root->right) {
        for (int i = path.size() - 1; i >= 0; i--) {
            cout << path[i] << " ";
        }
        cout << endl;
    }
    printAllPaths(root->left, path);
    printAllPaths(root->right, path);
    path.pop_back();
}

int main() {
    // 创建一棵二叉树
    BinaryTreeNode* root = createBinaryTree();

    // 中序遍历二叉树
    cout << "中序遍历结果为：";
    inorderTraversal(root);
    cout << endl;

    // 前序遍历二叉树
    cout << "前序遍历结果为：";
    preorderTraversal(root);
    cout << endl;

    // 后序遍历二叉树
    cout << "后序遍历结果为：";
    postorderTraversal(root);
    cout << endl;

    // 计算二叉树的深度
    cout << "二叉树的深度为：" << depthOfBinaryTree(root) << endl;

    // 统计二叉树的结点个数
    cout << "二叉树的结点个数为：" << countNodesOfBinaryTree(root) << endl;

    // 统计二叉树的叶结点个数
    cout << "二叉树的叶结点个数为：" << countLeafNodesOfBinaryTree(root) << endl;

    // 统计二叉树的度为1的结点个数
    cout << "二叉树的度为1的结点个数为：" << countNodesOfDegree1(root) << endl;

    // 输出二叉树中从每个叶子结点到根结点的路径
    vector<int> path;
    cout << "二叉树中从每个叶子结点到根结点的路径为：" << endl;
    printAllPaths(root, path);

    return 0;
}

输出结果为：

中序遍历结果为：4 2 5 1 6 3 7 
前序遍历结果为：1 2 4 5 3 6 7 
后序遍历结果为：4 5 2 6 7 3 1 
二叉树的深度为：3
二叉树的结点个数为：7
二叉树的叶结点个数为：4
二叉树的度为1的结点个数为：2
二叉树中从每个叶子结点到根结点的路径为：
4 2 1 
5 2 1 
6 3 1 
7 3 1