树[数据结构]

一.树的定义

1.什么是树

有且只有一个根节点，有若干个互不相交的子树。

2.专业术语

如上图：我们解释父节点、子节点、兄弟节点、堂兄弟节点。

父节点：A为父节点
子节点：B、C是A的子节点
兄弟节点：B和C是兄弟节点
堂兄弟节点：D与E是堂兄弟节点
深度：树中节点的最大层次（从根节点到最底层节点的层数，图中深度为3）
叶子节点：没有子节点的节点（B、E是叶子节点）
度：子节点的个数

二.树的分类

1.一般树

一般树：任意一个节点的子节点个数都不受限制。

2.二叉树

二叉树：任意一个节点的子节点个数最多为2个，且子节点位置不可更改。

3.森林

森林：n个互不相交的树的集合。

扩展：二叉树的分类

1.一般二叉树
2.满二叉树：在不增加树层次的前提下，不可添加新节点
3.完全二叉树：将满二叉树最底层最右边的连续若干个节点

如图，是一个满二叉树：

变成完全二叉树，可以不删除节点(完全二叉树包含满二叉树)，也可以删除 G、GE、GEF、GEFD.

三.树的存储

1.连续存储：

连续存储必须是完全二叉树的形式
为什么呢？

---

如下图，一颗普通树：

假设我们使用层次的关系（从左到右，从上到下的关系来存储）

该树在数组中的存储结构如下：

---

我们根据此数组将树还原：

到底是这种形式呢？

还是这种形式呢？

有歧义，不能确定节点的逻辑关系。
也就是，如果一棵树不是完全二叉树的形式，我们不能根据连续的存储结构来还原一棵树。
所以，连续的存储结构必须是完全二叉树的形式。

我们可以如下存储：

至此，我们总结一下连续结构存储完全二叉树的优缺点：

优点：
1.查找某个节点的父节点与子节点很快
2.可以通过编号确定节点在第几层

缺点：
浪费空间（如上面存储，还得存储空节点）

2.链式存储

我们将树的节点分为3部分构成：
pLeft指向左子树、pRight指向右子树、data存放节点数据。
如下图：

我们可以使用 先序遍历、中序遍历、后序遍历 遍历这棵树。

链式存储相对于连续存储来说，更节省空间，所以使用范围广。

3.非链式存储

对于下面树的存储：

1.双亲表示法

A：-1(代表A是根节点)
B：0（代表B的父节点是A）
C：0（代表C的父节点是A）
D：1（代表D的父节点是B）
E：1（代表E的父节点是B）

特点：求父节点很方便，但是求子节点麻烦。

2.孩子表示法

特点：求子节点很方便，但是求父节点麻烦。

3.双亲-孩子表示法

特点：求子节点很方便，求父节点也很方便，但是浪费空间。

4.二叉树表示法

对于一般树的存储，我们可以使用双亲表示法、孩子表示法、双亲-孩子表示法。
我们也可以将一棵树转换成二叉树来存储。
因为现在，我们对二叉树的算法比较成熟，对普通树的算法不成熟。所以我们通常将普通树转换成二叉树来存储，便于以后的操作。

我们将一颗普通树转变为二叉树来存储的规则是：左指针域指向第1个孩子，右指针域指向兄弟。

总结：
连续存储结构：浪费空间（必须是完全二叉树），但是查找速度快
链式存储结构：节约空间，查找速度还可以
非链式存储结构：最浪费空间
我们最常用的存储结构是：链式二叉树

四.树的操作

1.遍历

1.1前序遍历

前序遍历的顺序是：根节点-左子树-右子树
上面图片树的前序遍历为：A-B-D-E-C-F

1.2中序遍历

中序遍历的顺序是：左子树-根节点-右子树
上面图片树的前序遍历为：D-B-E-A-F-C

1.3后序遍历

后序遍历的顺序是：左子树-右子树-根节点
上面图片树的前序遍历为：D-E-B-F-C-A

2.根据遍历结果还原一棵树

我们可以根据：
先序遍历+中序遍历—>还原一棵树
中序遍历+后序遍历—>还原一棵树
但是不能：
前序遍历+后序遍历—>还原一棵树

因为：
前序遍历可以确定根节点，但是不能确定左子树、右子树。
后序遍历可以确定根节点，但是不能确定左子树、右子树。
中序遍历可以确定左子树、右子树，但是不能确定根节点。
所以：
先序遍历或后序遍历只有和中序遍历结合，才能确定一棵树的根节点、左子树、右子树。

我们在根据 先序+中序—>还原一棵树 或 中序+后序—>还原一棵树 的时候，有如下规律：

先序：最先出现的是根节点
后序：最后出现的是根节点
我们根据先序和后序的规律，再结合中序，就能轻松的还原一棵树。

具体的练习就不写了，其实并不难。

五.树的应用

1.是数据库中数据组织的一种重要方式（如图书管理数据库）
2.操作系统子父进程的关系就是一棵树。
3.面向对象中类的继承关系
等等…

六.编码实战

我们创建下面图中的这棵树，并且实现它的前序遍历，中序遍历、后序遍历。

#include <stdio.h>
#include <stdlib.h>
struct BTNode
{
    char data;
    struct BTNode * PTLchild;
    struct BTNode * PTRchild;
};
struct BTNode *createBTree();
void preTraverseBTree();
void inTraverseBTree();
void postTraverseBTree();
int main()
{
    struct BTNode * pT=createBTree();
    preTraverseBTree(pT);
    inTraverseBTree(pT);
    postTraverseBTree(pT);
    return 0;
}
//创建一棵树
struct BTNode *createBTree()
{
    struct BTNode * pA=(struct BTNode *)malloc(sizeof(struct BTNode));
    struct BTNode * pB=(struct BTNode *)malloc(sizeof(struct BTNode));
    struct BTNode * pC=(struct BTNode *)malloc(sizeof(struct BTNode));
    struct BTNode * pD=(struct BTNode *)malloc(sizeof(struct BTNode));
    struct BTNode * pE=(struct BTNode *)malloc(sizeof(struct BTNode));
    pA->data='A';
    pB->data='B';
    pC->data='C';
    pD->data='D';
    pE->data='E';
    pA->PTLchild=pB;
    pA->PTRchild=pC;
    pB->PTLchild=NULL;
    pB->PTRchild=NULL;
    pC->PTLchild=pD;
    pC->PTRchild=NULL;
    pD->PTLchild=NULL;
    pD->PTRchild=pE;
    pE->PTLchild=NULL;
    pE->PTRchild=NULL;
    return pA;
}
//先序遍历
void preTraverseBTree(struct BTNode * pT)
{
    if(pT!=NULL)
    {
        printf("%c\n",pT->data);
        if(pT->PTLchild!=NULL)
        {
             preTraverseBTree(pT->PTLchild);
        }
        if(pT->PTRchild!=NULL)
        {
            preTraverseBTree(pT->PTRchild);
        }
    }
}
//中序遍历
void inTraverseBTree(struct BTNode * pT)
{
    if(pT!=NULL)
    {
        if(pT->PTLchild!=NULL)
        {
             inTraverseBTree(pT->PTLchild);
        }
        printf("%c\n",pT->data);
        if(pT->PTRchild!=NULL)
        {
            inTraverseBTree(pT->PTRchild);
        }
    }

}
//后序遍历
void postTraverseBTree(struct BTNode * pT)
{
    if(pT!=NULL)
    {
        if(pT->PTLchild!=NULL)
        {
             postTraverseBTree(pT->PTLchild);
        }
        if(pT->PTRchild!=NULL)
        {
            postTraverseBTree(pT->PTRchild);
        }
        printf("%c\n",pT->data);
    }

}