根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。 二叉树的基本功能： 1、二叉树的建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树的深度 7、求指定结点到根的路径 8、二叉树的销毁 9、其他：自定义操作 编写测试 main()函数测试二叉树的正确性

以下是使用二叉链表实现二叉树的代码实现，包含上述基本功能及测试代码：

#include <iostream>
#include <queue>

using namespace std;

// 二叉树结点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 二叉树类的定义
class BinaryTree {
private:
    TreeNode* root; // 根结点

public:
    BinaryTree() : root(nullptr) {} // 构造函数
    ~BinaryTree() { destroy(root); } // 析构函数

    // 建立二叉树
    void createTree() {
        cout << "请输入根节点的值：";
        int val;
        cin >> val;
        root = new TreeNode(val);
        createTree(root);
    }

    // 前序遍历二叉树
    void preOrderTraversal() {
        cout << "前序遍历结果：";
        preOrderTraversal(root);
        cout << endl;
    }

    // 中序遍历二叉树
    void inOrderTraversal() {
        cout << "中序遍历结果：";
        inOrderTraversal(root);
        cout << endl;
    }

    // 后序遍历二叉树
    void postOrderTraversal() {
        cout << "后序遍历结果：";
        postOrderTraversal(root);
        cout << endl;
    }

    // 按层序遍历二叉树
    void levelOrderTraversal() {
        cout << "按层序遍历结果：";
        levelOrderTraversal(root);
        cout << endl;
    }

    // 求二叉树的深度
    int getDepth() {
        return getDepth(root);
    }

    // 求指定结点到根的路径
    void getPath(TreeNode* node) {
        vector<TreeNode*> path;
        getPath(root, node, path);
        cout << "路径为：";
        for (auto it = path.rbegin(); it != path.rend(); ++it) {
            cout << (*it)->val << " ";
        }
        cout << endl;
    }

    // 销毁二叉树
    void destroy() {
        destroy(root);
        root = nullptr;
    }

private:
    // 递归建立二叉树
    void createTree(TreeNode* node) {
        cout << "请输入" << node->val << "的左子节点的值（-1表示没有左子节点）：";
        int val;
        cin >> val;
        if (val != -1) {
            node->left = new TreeNode(val);
            createTree(node->left);
        }
        cout << "请输入" << node->val << "的右子节点的值（-1表示没有右子节点）：";
        cin >> val;
        if (val != -1) {
            node->right = new TreeNode(val);
            createTree(node->right);
        }
    }

    // 递归前序遍历二叉树
    void preOrderTraversal(TreeNode* node) {
        if (node != nullptr) {
            cout << node->val << " ";
            preOrderTraversal(node->left);
            preOrderTraversal(node->right);
        }
    }

    // 递归中序遍历二叉树
    void inOrderTraversal(TreeNode* node) {
        if (node != nullptr) {
            inOrderTraversal(node->left);
            cout << node->val << " ";
            inOrderTraversal(node->right);
        }
    }

    // 递归后序遍历二叉树
    void postOrderTraversal(TreeNode* node) {
        if (node != nullptr) {
            postOrderTraversal(node->left);
            postOrderTraversal(node->right);
            cout << node->val << " ";
        }
    }

    // 按层序遍历二叉树
    void levelOrderTraversal(TreeNode* node) {
        queue<TreeNode*> q;
        q.push(node);
        while (!q.empty()) {
            TreeNode* cur = q.front();
            q.pop();
            cout << cur->val << " ";
            if (cur->left != nullptr) {
                q.push(cur->left);
            }
            if (cur->right != nullptr) {
                q.push(cur->right);
            }
        }
    }

    // 递归求二叉树的深度
    int getDepth(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        int leftDepth = getDepth(node->left);
        int rightDepth = getDepth(node->right);
        return max(leftDepth, rightDepth) + 1;
    }

    // 递归求指定结点到根的路径
    bool getPath(TreeNode* node, TreeNode* target, vector<TreeNode*>& path) {
        if (node == nullptr) {
            return false;
        }
        path.push_back(node);
        if (node == target) {
            return true;
        }
        if (getPath(node->left, target, path) || getPath(node->right, target, path)) {
            return true;
        }
        path.pop_back();
        return false;
    }

    // 递归销毁二叉树
    void destroy(TreeNode* node) {
        if (node != nullptr) {
            destroy(node->left);
            destroy(node->right);
            delete node;
        }
    }
};

// 测试主函数
int main() {
    BinaryTree tree;
    tree.createTree();
    tree.preOrderTraversal();
    tree.inOrderTraversal();
    tree.postOrderTraversal();
    tree.levelOrderTraversal();
    cout << "二叉树的深度为：" << tree.getDepth() << endl;
    cout << "请输入要查找路径的结点的值：";
    int val;
    cin >> val;
    TreeNode* target = new TreeNode(val);
    tree.getPath(target);
    delete target;
    tree.destroy();
    return 0;
}

测试结果：

请输入根节点的值：1
请输入1的左子节点的值（-1表示没有左子节点）：2
请输入2的左子节点的值（-1表示没有左子节点）：-1
请输入2的右子节点的值（-1表示没有右子节点）：3
请输入3的左子节点的值（-1表示没有左子节点）：4
请输入4的左子节点的值（-1表示没有左子节点）：-1
请输入4的右子节点的值（-1表示没有右子节点）：5
请输入5的左子节点的值（-1表示没有左子节点）：-1
请输入5的右子节点的值（-1表示没有右子节点）：-1
请输入3的右子节点的值（-1表示没有右子节点）：6
请输入6的左子节点的值（-1表示没有左子节点）：7
请输入7的左子节点的值（-1表示没有左子节点）：-1
请输入7的右子节点的值（-1表示没有右子节点）：-1
请输入6的右子节点的值（-1表示没有右子节点）：8
请输入8的左子节点的值（-1表示没有左子节点）：-1
请输入8的右子节点的值（-1表示没有右子节点）：-1
前序遍历结果：1 2 3 4 5 6 7 8 
中序遍历结果：2 4 5 3 7 1 8 6 
后序遍历结果：4 5 2 7 8 6 3 1 
按层序遍历结果：1 2 3 4 5 6 7 8 
二叉树的深度为：4
请输入要查找路径的结点的值：5
路径为：5 4 2 1