树以孩子兄弟链表为存储结构，根据文件内容，使用C++语言，设计类TreeNode和Tree,并算法完成如下题目： （1）求树的深度。 （2）求树的度。

根据提供的文件内容，我们可以设计 `TreeNode` 和 `Tree` 类，并实现求树的深度和度的功能。以下是详细的代码实现：

### TreeNode 类
`TreeNode` 类表示树的一个节点，包含数据域和两个指针域：一个指向其第一个子节点，另一个指向其下一个兄弟节点。

#ifndef TREENODE_H
#define TREENODE_H

template <class DataType>
class TreeNode {
public:
    DataType data;           // 数据域
    TreeNode<DataType> *firstChild;  // 指向第一个子节点
    TreeNode<DataType> *nextSibling; // 指向下一个兄弟节点

    // 构造函数
    TreeNode(DataType d = DataType(), TreeNode<DataType> *fc = nullptr, TreeNode<DataType> *ns = nullptr)
        : data(d), firstChild(fc), nextSibling(ns) {}
};

#endif // TREENODE_H

### Tree 类
`Tree` 类表示一棵树，包含根节点指针和其他相关方法。

#ifndef TREE_H
#define TREE_H

#include "TreeNode.h"
#include "LinkQueue.h"

template <class DataType>
class Tree {
private:
    TreeNode<DataType> *root;  // 根节点指针

public:
    Tree() : root(nullptr) {}  // 默认构造函数
    ~Tree();                   // 析构函数

    void CreateTree();         // 创建树
    void PreOrder(void (*visit)(const DataType &)) const;  // 前序遍历
    void PostOrder(void (*visit)(const DataType &)) const; // 后序遍历
    void LevelOrder(void (*visit)(const DataType &)) const; // 层次遍历
    int Height() const;        // 求树的深度
    int Degree() const;        // 求树的度

private:
    void PreOrder(TreeNode<DataType> *node, void (*visit)(const DataType &)) const;
    void PostOrder(TreeNode<DataType> *node, void (*visit)(const DataType &)) const;
    int Height(TreeNode<DataType> *node) const;
    int Max(int a, int b) const;
    int Degree(TreeNode<DataType> *node) const;
};

// 析构函数
template <class DataType>
Tree<DataType>::~Tree() {
    if (root != nullptr) {
        // 清理树的所有节点
        PostOrder(root, [](const DataType &) {});
    }
}

// 创建树
template <class DataType>
void Tree<DataType>::CreateTree() {
    char ch;
    cin >> ch;
    if (ch == '#') {
        root = nullptr;
    } else {
        root = new TreeNode<DataType>(ch);
        TreeNode<DataType> *parent = root;
        queue<TreeNode<DataType>*> q;
        q.push(parent);

        while (cin >> ch && !q.empty()) {
            TreeNode<DataType> *current = q.front();
            q.pop();

            if (ch != '#') {
                current->firstChild = new TreeNode<DataType>(ch);
                q.push(current->firstChild);
            }

            while (cin >> ch && ch != '#') {
                if (ch != '#') {
                    current->nextSibling = new TreeNode<DataType>(ch);
                    current = current->nextSibling;
                    q.push(current);
                }
            }
        }
    }
}

// 前序遍历
template <class DataType>
void Tree<DataType>::PreOrder(void (*visit)(const DataType &)) const {
    PreOrder(root, visit);
}

template <class DataType>
void Tree<DataType>::PreOrder(TreeNode<DataType> *node, void (*visit)(const DataType &)) const {
    if (node != nullptr) {
        visit(node->data);
        for (TreeNode<DataType> *child = node->firstChild; child != nullptr; child = child->nextSibling) {
            PreOrder(child, visit);
        }
    }
}

// 后序遍历
template <class DataType>
void Tree<DataType>::PostOrder(void (*visit)(const DataType &)) const {
    PostOrder(root, visit);
}

template <class DataType>
void Tree<DataType>::PostOrder(TreeNode<DataType> *node, void (*visit)(const DataType &)) const {
    if (node != nullptr) {
        for (TreeNode<DataType> *child = node->firstChild; child != nullptr; child = child->nextSibling) {
            PostOrder(child, visit);
        }
        visit(node->data);
    }
}

// 层次遍历
template <class DataType>
void Tree<DataType>::LevelOrder(void (*visit)(const DataType &)) const {
    if (root == nullptr) return;

    LinkQueue<TreeNode<DataType>*> q;
    q.EnQueue(root);

    while (!q.IsEmpty()) {
        TreeNode<DataType> *node;
        q.GetHead(node);
        q.DelQueue(node);

        visit(node->data);

        for (TreeNode<DataType> *child = node->firstChild; child != nullptr; child = child->nextSibling) {
            q.EnQueue(child);
        }
    }
}

// 求树的深度
template <class DataType>
int Tree<DataType>::Height() const {
    return Height(root);
}

template <class DataType>
int Tree<DataType>::Height(TreeNode<DataType> *node) const {
    if (node == nullptr) return 0;

    int maxDepth = 0;
    for (TreeNode<DataType> *child = node->firstChild; child != nullptr; child = child->nextSibling) {
        maxDepth = Max(maxDepth, Height(child));
    }

    return 1 + maxDepth;
}

// 求树的度
template <class DataType>
int Tree<DataType>::Degree() const {
    return Degree(root);
}

template <class DataType>
int Tree<DataType>::Degree(TreeNode<DataType> *node) const {
    if (node == nullptr) return 0;

    int maxDegree = 0;
    for (TreeNode<DataType> *child = node->firstChild; child != nullptr; child = child->nextSibling) {
        int childDegree = 1 + Degree(child);
        maxDegree = Max(maxDegree, childDegree);
    }

    return maxDegree;
}

// 辅助函数
template <class DataType>
int Tree<DataType>::Max(int a, int b) const {
    return (a > b) ? a : b;
}

#endif // TREE_H

### 主函数
在主函数中创建树并调用相关方法进行测试。

#include <iostream>
#include "Tree.h"

template <class DataType>
void Display(const DataType &e) {
    cout << e << " ";
}

int main() {
    Tree<char> tree;
    cout << "Please enter the preorder sequence of a tree, # is null pointer (ABE#FK#L###CG##DH#IM#N##J####):" << endl;
    tree.CreateTree();

    cout << "The preorder sequence of the tree is:" << endl;
    tree.PreOrder(Display);
    cout << endl;

    cout << "The postorder sequence of the tree is:" << endl;
    tree.PostOrder(Display);
    cout << endl;

    cout << "The level order sequence of the tree is:" << endl;
    tree.LevelOrder(Display);
    cout << endl;

    cout << "The height of the tree is: " << tree.Height() << endl;

    cout << "The degree of the tree is: " << tree.Degree() << endl;

    system("pause");
    return 0;
}

以上代码实现了树的基本操作，包括前序遍历、后序遍历、层次遍历、求树的深度和度。希望这些代码对你有所帮助！