参考用书：王道考研《2024年数据结构考研复习指导》

参考用书配套视频：5.1.1 树的定义和基本术语_哔哩哔哩_bilibili

特别感谢： Chat GPT老师[部分名词解释、修改BUG]、BING老师[封面图]~

备注：博文目前是未完成的状态，如题，目前只写了树的存储结构~~本博文篇幅较长，笔者无法一次全部更新，毕竟我的编程水平就是个两脚Bug生成兽，经常1段代码可以卡1天，完成时间初步预计为23.06.17~ 🥲

考研笔记整理，内容预计包含树~~、二叉树与森林~~的基本概念、存储结构，~~构造与遍历、树、森林与二叉树的转换，~~代码为C++~考研一起加油~ 🫡

第1版：查资料、写BUG、画导图、画配图ing~

思维导图

树

树的概念

树的定义：树是n（n≥0）个结点的有限集。当n=0时，称为空树。在任意一棵非空树应满足：

有且仅有一个特定的称为根的结点。
当n＞1时，其余结点可分为m(m>0)个互不相交的有限集T1，T2，...，Tm，其中每个集合本身又是一棵树，并且称为根的子树。 //因此，树是递归的数据结构

树的基本术语

图：树的图形表示+术语注释

（1）结点、度

结点：一种数据结构，包含数据和对一个或多个其他节点的引用（例如：指针）。
根结点：树的根节点没有前驱，除根结点以外的所有结点有且仅有1个前驱；
分支结点：除根节点外，度＞0的结点称为分支结点；
分支结点：除根节点外，度 = 0的结点称为分支结点；
结点关系：
祖先结点：从根结点到指定结点的路径上的所有结点，例如结点A、B、E均为结点K的祖先结点；
子孙结点：从指定结点到叶子点的路径上的所有结点，例如结点K、L、F均为结点B的子孙结点；
双亲结点：祖先结点中最接近指定结点的结点，例如结点E是结点K、L的双亲结点。
孩子结点：子孙结点中最接近指定结点的结点，例如结点E、F是结点B的孩子结点。
兄弟结点：具有相同父节点的两个结点，例如结点K与结点L是兄弟结点。
度数：
结点的度：树中一个结点的孩子个数称为度数。
树的度：树中结点的最大度数称为数的度。例如图中结点的度数为3，因此这棵树的结点就是3。

（2）层次、深度、高度：

层次：一个节点的层级是从根节点到该节点的边数。
高度：树中结点的最大层数。

（3）路径：

路径：两个结点之间的路径是由这两个结点之间所经过的结点序列构成的；
结点的路径长度：两个指定结点路径上经过的边的个数。
树的路径长度：树根到每个结点的路径长度的总和。

（4）有序、无序：

有序树：是节点按特定顺序排列的树，结点之间不能互换，例如二叉搜索树。
无序树：是指节点未按任何特定顺序排列的树。

树的基本性质

（1）结点与结点、结点与边

n个结点的树有 n-1条边；// 根节点无前驱，因此无指向根结点的边~
树中的结点数 - 1 = $\sum$ 所有结点的度数； // 结点的度数代表孩子结点的个数，根节点为特殊的无前驱的结点，因此需要 -1；

（2）结点与度

度为m的树，在第 i 层上结点数 ≤ m^(i-1)； // 按照结点的度均为m的情况考虑，第1层最多有m^(1-1)=1个结点，第2层最多有m^(2-1)=m个结点...递推可求~

（3）结点与高

高度为h的m叉树结点数 n ≤ （m^h -1）/（m-1）； // 等比公式可求，Sn=首项（1-公比的n次方）/（1-公比）

嗯，这个我们以满3叉树(m=3)举栗：

结点与高度的公式推算
层数(h)	本层最多结点数	首层累加至本层结点数
3叉树第1层	m^（h-1）=3^（1-1）= 1	3^0 = 1
3叉树第2层	m^（h-1）=3^（2-1）= 3	3^0 + 3^1 = 4
3叉树第3层	m^（h-1）=3^（3-1）= 9	3^0 + 3^1 + 3^2 = 13
3叉树第4层	m^（h-1）=3^（4-1）= 27	3^0 + 3^1 + 3^2+ 3^3 = 40
...	...	...
3叉树第h层	m^（h-1）=3^（h-1）	3^0 + 3^1 + 3^2+ ... +3^（h-1） = 1 x（1- 3^h）/（1-3） =（3^h -1）/ （3-1）
m叉树第h层	m^（h-1）	（m^h -1）/ （m-1）

树的存储结构

双亲表示法

描述：这种存储结构采用一组连续空间来存储每个结点，同时在每个结点中增加一个伪指针，指示其双亲结点在数组中的位置。

特点：

简洁直观：相比其它存储方式易于理解与实现。
存储结构：顺序存储和链式存储均可实现，其中顺序存储较为常见。
存取效率：可以很快得到每个结点的双亲结点，但求孩子结点时需要遍历整个结构；不过这并不是硬伤，可以根据需要在结构体中增加一个用于存放孩子结点的伪指针。// 所以这里叫做顺序存储法是不是比双亲存储法更合适一些~~
是否有序：双亲表示法不适合表示有序树，更适合表示无序树，因为无序树中节点的子节点没有明确的顺序关系。

图示：源于《王道》教材图5.14 树的双亲表示法

双亲表示法顺序存储结构核心代码：

#define MAX_TREE_SIZE 100   //树中可以存储的结点数

typedef struct{     //树中结点的结构，该结构有两个字段
    ElemType data;   //该字段存储结点的数据元素
    int parent;      //该字段存储结点的双亲指针（伪指针）
}PTNode;

typedef struct{     //树的结构，该结构有两个字段
    PTNode nodes[MAX_TREE_SIZE];   //结构数组，用于存储树中的结点
    int n;                         //树中的结点数
}PTree;

双亲表示法顺序存储结构案例：

要求：存储上图中的树，并顺序输出结点~

思路：

LocateElem封装按值查找函数，并寻找双亲与孩子结点~

用2个整型参数i、j，记录并遍历本结点与父节点的位序；

找到目标结点后，输出当前结点的信息以及父结点的信息；

通过循环寻找并输出孩子结点的信息，同时记录子结点的数量；如果子结点的数量为0，则输出没有子结点的提示信息；[这一步时间开销会很高，仅寻找相邻结点]；

如果遍历到末尾没有找到结点，则输出没有该结点的提示信息。

get封装按为查找函数，并寻找祖先与子孙结点~

判断树中是为空，如果是，返回错误；如果否，继续执行；
判断值是否越界，如果是，返回错误；如果否，继续执行；
输出目标结点的data与parent；

通过递归寻找并输出祖先/子孙结点的信息，同时记录子结点的数量；如果子结点的数量为0，则输出没有子结点的提示信息；如果父节点已为根结点，则反馈到第2步；[这一步时间开销会很高，可寻找所有祖先/子孙结点]；

#include <iostream>
#define MAX_TREE_SIZE 100

typedef struct{
    char data;
    int parent;
}PTNode;

typedef struct{
    PTNode nodes[MAX_TREE_SIZE];
    int n;
}PTree;

void InitTree(PTree* tree) {
    for(int i = 0; i < MAX_TREE_SIZE; i++){
        tree->nodes[i].data = 0;
        tree->nodes[i].parent = -1;
    }
    tree->n = 0;
}

void addNode(PTree* tree, char data, int parentIndex) {
    if (tree->n >= MAX_TREE_SIZE) {
        std::cout <<"错误：树已满，不能再添加数据。\n";
        return;
    }

    PTNode newNode;
    newNode.data = data;

    if (parentIndex < 0){
        newNode.parent = -1;
    }else{
        newNode.parent = parentIndex;
    }

    tree->nodes[tree->n] = newNode;
    tree->n++;

}

void LocateElem(const PTree* tree, char data) {
    int i, j;
    int childCount = 0;
    int firstChildPos = -1;

    for (i = 0, j = -1; i < tree->n; i++) {
        if (tree->nodes[i].data == data) {
            std::cout << "找到结点 " << data << std::endl;
            std::cout << "当前结点信息：" << "位置: " << i << ", 数据: " << tree->nodes[i].data << ", 双亲位置: " << tree->nodes[i].parent << std::endl;

            j = tree->nodes[i].parent;
            if (j != -1) {
                std::cout << "父节点信息：" << "位置: " << j << ", 数据: " << tree->nodes[j].data << ", 双亲位置: " << tree->nodes[j].parent << std::endl;
            }

            for (int k = 0; k < tree->n; k++) {
                if (tree->nodes[k].parent == i) {
                    if (childCount == 0) {
                        firstChildPos = k;
                    }
                    std::cout << "子节点信息：" << "位置: " << k << ", 数据: " << tree->nodes[k].data << ", 双亲位置: " << tree->nodes[k].parent << std::endl;
                    childCount++;
                }
            }

            if (childCount == 0) {
                std::cout << "该结点没有子节点" << std::endl;
            } else {
                std::cout << "子节点数量: " << childCount << std::endl;
              //std::cout << "第一个子节点信息：" << "位置: " << firstChildPos << ", 数据: " << tree->nodes[firstChildPos].data << ", 双亲位置: " << tree->nodes[firstChildPos].parent << std::endl;
            }

            return;
        }
    }

    std::cout << "未找到结点 " << data << std::endl;
}


void GetOffspring(const PTree& tree, int index) {
    if (index < 0 || index >= tree.n) {
        std::cout << "错误：索引越界。\n";
        return;
    }

    const PTNode& currentNode = tree.nodes[index];

    std::cout << "结点位置: " << index << ", 数据: " << currentNode.data << ", 父节点位置: " << currentNode.parent << std::endl;

    int childCount = 0;

    for (int i = 0; i < tree.n; i++) {
        if (tree.nodes[i].parent == index) {
            childCount++;
            GetOffspring(tree, i);  // 递归调用时传递孩子结点的索引
        }
    }

    if (childCount == 0) {
        std::cout << "该结点没有孩子结点。\n";
    }

}

void GetAncestors(const PTree& tree, int index) {
    if (index < 0 || index >= tree.n) {
        std::cout << "错误：索引越界。\n";
        return;
    }

    const PTNode& currentNode = tree.nodes[index];

    std::cout << "结点位置: " << index << ", 数据: " << currentNode.data << ", 父节点位置: " << currentNode.parent << std::endl;

    int parentIndex = currentNode.parent;
    if (parentIndex >= 0) {
        GetAncestors(tree, parentIndex);
    }

}

int main() {
    PTree newtree;
    // 初始化树对象
    InitTree(&newtree);

    // 增加节点
    char data;
    int parentIndex;
    while (std::cout << "输入结点: " && std::cin >> data && data != '\\') {
        std::cout << "输入结点的双亲位置: ";
        std::cin >> parentIndex;
        addNode(&newtree, data, parentIndex);
    }

    std::cout << std::endl;

    // 输出结点
    for (int i = 0; i < newtree.n; i++) {
        std::cout << "结点位置: " << i << ", 数据: " << newtree.nodes[i].data << ", 父节点位置: " << newtree.nodes[i].parent << std::endl;
    }

    std::cout << std::endl;

    // 输出按值查找结点信息
    char target1;
    std::cout << "请输入要按值查找的结点: ";
    std::cin >> target1;
    LocateElem(&newtree, target1);

    std::cout << std::endl;

    // 输出子孙结点
    int targetIndex1;
    std::cout << "寻找该位序的子孙结点: ";
    std::cin >> targetIndex1;
    GetOffspring(newtree, targetIndex1);

    std::cout << std::endl;

    // 输出祖先结点
    int targetIndex2;
    std::cout << "寻找该位序的祖先结点: ";
    std::cin >> targetIndex2;
    GetAncestors(newtree, targetIndex2);

    return 0;
}

运行的效果如下图所示：