《大话数据结构》学习记录6——树

树

一、定义

树 (Tree) 是 $n(n\ge 0)$ 个结点的有限集。$n=0$ 时称为空树。在任意一棵非空树中：
(1) 有且仅有一个特定的称为根 (Root) 的结点;
(2) 当 $n>1$ 时，其余结点可分为 $m(m>0)$ 个互不相交的有限集$T_1、T_2、\dots \dots 、T_m$, 其中每一个集合本身又是一棵树，并且称为根的子树 (SubTree)

1、错误情况

2、结点分类

• 树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度（Degree）。
  • 度为 0 的结点称为叶结点（Leaf）或终端结点；
  • 度不为 0 的结点称为非终端结点或分支结点。
  • 除根结点之外，分支结点也称为内部结点。
  • 树的度是树内各结点的度的最大值。
  • 

3、节点间的关系

• 结点的子树的根称为该结点的孩子（Child）
• 相应地，该结点称为孩子的双亲（Parent）
• 同一个双亲的孩子之间互称兄弟（Sibling）
• 结点的祖先是从根到该结点所经分支上的所有结点
• 以某结点为根的子树中的任一结点都称为该结点的子孙
  

4、树的其他相关概念

• 结点的层次 (Level) 从根开始定义起，根为第一层，根的孩子为第二层。

  • 若某结点在第 n 层，则其子树的根就在第 n+1 层。其双亲在同一层的结点互为堂兄弟。显然D、E、F 是堂兄弟，而 G、H、I、J 也是。
  • 树中结点的最大层次称为树的深度 (Depth) 或高度，当前树的深度为 4。
  • 

• 如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。

• 森林 (Forest) 是 m (m>0) 棵互不相交的树的集合。

  • 对树中每个结点而言，其子树的集合即为森林。

二、树的抽象数据类型

InitTree ( *T)：构造空树 T
DestroyTree ( *T )：销毁树 T
CreateTree ( *Tr definition )：按 definition 中给出树的定义来构造树
ClearTree ( *T )：若树 T 存在，则将树 T 清为空树
TreeEmpty ( T ) ：若 T 为空树，返回 true, 否则返回 false
TreeDepth(T)：返回 T 的深度
Root(T)：返回 T 的根结点
Value(T,cur_e)：cur_e 是树 T 中一个结点，返回此结点的值
Assign ( T,cur_e,value )：给树 T 的结点 cur_e 赋值为 value
Parent( T,cur_e )：若 cur_e 是树 T 的非根结点, 则返回它的双亲，否则返回空
Leftchild( T,cur_e )：若cur_e 是树 T 的非叶结点，则返回它的最左孩子，否则返回空
Rightsibling(Trcur_e)：若 cur_e 有右兄弟. 则返回它的右兄弟，否则返回空
Insertchild ( *T,*p,i,c )：其中 p 指向树 T 的某个结点，i 为所指结点 p 的度加上1,非空树 c 与 T 不相交，操作结果为插入 c 为树 T 中 p 指结点的第 i 棵子树
DeleteChild ( *T,*p,i)：其中p 指向树 T 的某个结点，i 为所指结点 p 的度，操作结果为翻除 T 中 p 所指结点的第 i 裸子树

三、树的存储结构

1、双亲表示法

人可能没有孩子，但人一定会有父母。
假设以一组连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点到链表中的位置。

• data 是数据域，存储结点的数据信息。
• parent 是指针域，存储该结点的双亲在数组中的下标。

① 双亲表示法的结点结构定义代码

/* 树的双亲表示法结点结构定义 */

#define MAX_TREE__SIZE 100
typedef int TElemType; /* 树结点的数据类型. 目前暂定为整型 */
typedef struct PTNode /* 结点结构 */
{
TElemType data;  /* 结点数据 */
int parent;      /* 双亲位置 */
} PTNode;

typedef struct      /* 树结构 */
{
    PTNode nodes [MAX_TREE_SIZE]; /* 结点敷组 */
    int r,n;                /* 根的位置和结点数 */
} PTree; 

• 由于根结点是没有双亲的，所以我们约定根结点的位置域设置为-1

• 例子

  • 

② 扩展情况

存储结构的设计是一个非常灵活的过程。一个存储结构设计得是否合理，取决于基于该存储结构的运算是否适合、是否方便，时间复杂度好不好等。

• 特别情况1 —— 想知道结点的孩子是什么需要遍历整个结构才行

  • 增加一个结点最左边孩子的域——长子域，即长子的下标，无子为-1
  • 按照上例
    

• 特别情况2 —— 很关注各兄弟之间的关系，双亲表示法无法体现这样的关系

  • 增加一个右兄弟域来体现兄弟关系。如果它存在右兄弟，则记录下右兄弟的下标。如果右兄弟不存在，则赋值为-1。
  • 按照上例
    

• 特别情况3——如果结点的孩子很多，超过了 2 个。我们又关注结点的双亲、又关注结点的孩子、还关注结点的兄弟，而且对时间遍历要求还比较高

  • 那么我们还可以把此结构扩展为有双亲域、长子域、再有右兄弟域。

2、孩子表示法

每个结点有多个指针域，其中每个指针指向一棵子树的根结点，我们把这种方法叫做多重链表表示法。

① 方案1

• 指针域的个数就等于树的度。
  

其中 data 是数据域。childl 到 childd 是指针域，用来指向该结点的孩子结点。

• 例子
  

• 这种方法对于树中各结点的度相差很大时，显然是很浪费空间的，因为有很多的结点，它的指针域都是空的。不过如果树的各结点度相差很小时，那就意味着开辟的空间被充分利用了，这时存储结构的缺点反而变成了优点。

② 方案2

• 每个结点指针域的个数等于该结点的度，我们专门取一个位置来存储结点指针域的个数
  

其中 data 为数据域，degree 为度域，也就是存储该结点的孩子结点的个数,child1 到 childd 为指针域，指向该结点的各个孩子的结点。

• 例子
  

• 这种方法克服了浪费空间的缺点，对空间利用率是很高了，但是由于各个结点的链表是不相同的结构，加上要维护结点的度的数值，在运算上就会带来时间上的损耗。

③ 方案3——孩子表示法

把每个结点的孩子结点排列起来，以单链表作存储结构，则 n 个结点有 n 个孩子链表，如果是叶子结点，则此单链表为空。
然后 n 个头指针又组成一个线性表，采用顺序存储结构，存放进一个一维数组。

• 表头数组结构：所有节点存储在顺序结构的一维数组，

  • 

• 孩子链表结构：各节点的父子关系，通过孩子法表示。每个节点，对应孩子链表，按照长子、次子等等顺序，依次列下去

  • 

• 代码实现：

/* 树的孩子表示法结构定义 */
#define MAX_TREE_SIZE 100
typedef struct CTNode   /* 孩子结点 */
{
    int child;
    struct CTNode *next;
} *ChildPtr;
typedef struct      /* 表头结构 */
{
    TElemType data;
    ChildPtr firstchild;
} CTBox;
typedef struct      /* 树结构 */
{
    CTBox nodes [MAX_TREE_SIZE]; /* 结点数组 */
    int r,n;        /* 根的位置和结点数 */
} CTree;

• 这样的结构对于我们要查找某个结点的某个孩子，或者找某个结点的兄弟，只需要查找这个结点的孩子单链表即可。对于遍历整棵树也是很方便的，对头结点的数组循环即可

• 问题：如何知道某个结点的双亲是谁呢？比较麻烦，需要整棵树遍历才行

  • 双亲孩子表示法
  • 

3、孩子兄弟表示法

任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟。

其中 data 是数据域，firstchild 为指针域，存储该结点的第一个孩子结点的存储地址，rightsib 是指针域，存储该结点的右兄弟结点的存储地址。

• 代码

/* 树的孩子兄弟表示法姑构定义 */
typedef struct CSNode
{
    TElemType data;
    struct CSNode *firstchild,*rightsib;
} CSNode,*CSTree;

• 例子
  

• 优势
  这种表示法，给查找某个结点的某个孩子带来了方便，只需要通过 fistchild 找到此结点的长子，然后再通过长子结点的 rightsib 找到它的二弟，接着一直下去，直到找到具体的孩子

• 缺点——不能找某个结点的双亲

  • 再增加一个 parent 指针域来解决快速查找双亲的问题

四、二叉树

二叉树（ Binary Tree ）是 $n(n\ge 0)$个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。

1、特点和形态

• 特点：
  • 每个结点最多有两棵子树，所以二叉树中不存在度大于 2 的结点。注意不是只有两棵子树，而是最多有。没有子树或者有一棵子树都是可以的。
  • 左子树和右子树是有顺序的，次序不能任意颠倒。就像人是双手、双脚，但显然左手、左脚和右手、右脚是不一样的，右手戴左手套、右脚穿左鞋都会极其别扭和难受。
  • 即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。
• 形态
  • 空二叉树。
  • 只有一个根结点。
  • 根结点只有左子树。
  • 根结点只有右子树
  • 根结点既有左子树又有右子树

2、特殊二叉树

• 所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。
• 在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。
• 对一棵具有 n 个结点的二叉树按层序编号，如果编号为 i 的结点与同样深度的满二叉树中编号为 i 的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树
  • 叶子结点只能出现在最下两层。
  • 最下层的叶子一定集中在左部连续位置。
  • 倒数二层，若有叶子结点，一定都在右部连续位置。
  • 如果结点度为1, 则该结点只有左孩子，即不存在只有右子树的情况。
  • 同样结点数的二叉树，完全二叉树的深度最小。

3、二叉树性质

• 性质1: 在二叉树的第$i$层上至多有$2^{i-1}$个结点 ($i\ge 1$)
• 性质2: 深度为 k 的二叉树至多有 $2^{k-1}$个结点 ($k\ge 1$)
• 性质 3: 对任何一棵二叉树 T, 如果其终端结点数为 $n_0$, 度为 2 的结点数为 $n_2$，则 $n_0=n_2+1$
  • 终端结点数其实就是叶子结点数，而一棵二叉树，除了叶子结点外，剩下的就是度为 1 或 2 的结点数
• 性质 4：具有n个结点的完全二叉树的深度为$[lo{g}_{2}n]+1$([x]表示不大于 x 的最大整数)。
• 性质 5: 如果对一棵有 n 个结点的完全二叉树（其深度为$[lo{g}_{2}n]+1$）的结点按层序编号（从第 1 层到第$[lo{g}_{2}n]+1$层，每层从左到右），对任一结点$i(1\le i\le n)$有：
  • 1. 如果 i=1, 则结点i 是二叉树的根，无双亲；如果 i>1, 则其双亲是结点[i/2]
  • 2. 如果 2i>n, 则结点i 无左孩子（结点 i 为叶子结点）；否则其左孩子是结点2i
  • 3. 如果 2i+1>n, 则结点 i 无右孩子；否则其右孩子是结点2i+1

4、二叉树的存储结构

① 顺序存储结构

二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如双亲与孩子的关系，左右兄弟的关系等。

• 完全二叉树
  • 完全二叉树存入到数组中，相应的下标对应其同样的位置。后n-2^t个为叶结点。
• 一般的二叉树
  • 尽管层序编号不能反映逻辑关系，但是可以将其按完全二叉树编号，把不存在的结点设置为^
  • 考虑一种极端的情况，一棵深度为 k 的右斜树，它只有 k 个结点，却需要分配 2k-l个存储单元空间，这显然是对存储空间的浪费
  • 顺序存储结构一般只用于完全二叉树

② 二叉链表

二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。

其中 data 是数据域，khild 和 rchild 都是指针域，分别存放指向左孩子和右孩子的指针。

• 代码

  /* 二又树的二叉链表结点结构定义 */
  typedef struct BiTNode /* 结点结构 */
  {
    TElemType data; /* 结点数据 */
    struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
  } BiTNode, *BiTree;
  

  

• 如果有需要，还可以再增加一个指向其双亲的指针域，那样就称之为三叉链表

5、遍历二叉树

二叉树的遍历 ( traversing binary tree ) 是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

① 前序遍历

• 规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树。

• 

• /* 二叉树的前序遍历递归算法 */
  void PreOrderTraverse ( BiTree T)
  {
    if(T==NULL)
      return;
    printf("%c",T->data); /* 显示结点数据, 可以更改为其他对结点操作 */
    PreOrderTraverse ( T->lchild ); /* 再先序遍历左子树 */
    PreOrderTraverse ( T->rchild) ; /* 最后先序遍历右子树 */
  }
  

② 中序遍历

• 规则是若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树。
  +

• /* 二叉树的中序遍历递归算法 */
  void InOrderTraverse ( BiTree T)
  {
    if(T==NULL)
      return;
    InOrderTraverse(T->lchild);   /* 中序遍历左子树 */
    printf("%c",T->data);         /* 显示结点数据, 可以更改为其他对结点操作 */
    InOrderTraverse(T->rchild) ;  /* 最后中序遍历右子树 */
  }
  

③ 后序遍历

• 规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。

• 

• /* 二叉树的中序遍历递归算法 */
  void PostOrderTraverse ( BiTree T)
  {
    if(T==NULL)
      return;
    PostOrderTraverse(T->lchild);   /* 中序遍历左子树 */
    PostOrderTraverse(T->rchild) ;  /* 最后中序遍历右子树 */
    printf("%c",T->data);         /* 显示结点数据, 可以更改为其他对结点操作 */
  }
  

④ 层序遍历

• 规则是若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问
• 

6、二叉树的建立

引入原二叉树的扩展二叉树。

• 例子：前序遍历序列为 AB#D##C##
  

  • /* 按前序檎入二又树中结点的值(一个字符) */
    /* #表示空树，构造二叉链表表示二又树T。*/
    void CreateBiTree ( BiTree *T)
    {
      TElemType ch;
      scanf("%c",&ch);
      if(ch=="#")
        *T=NULL;
      else
      {
        *T=(BiTree)malloc(sizeof(BiTNode));
        if(!*T)
          exit(OVERFLOW);
        (*T)->data=ch; /* 生成根结点*/
        CreateBiTree(& (*T)->lchild); /* 构造左子树 */
        CreateBiTree(& (*T)->rchild); /* 构造右子树 */
      }
    }
    

7、线索二叉树

指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树（Threaded Binary Tree）

• 对二叉树以某种次序遍历使其变为线索二叉树的过程称做是线索化
• 增设标志域 ltag 和 rtag

  • 

  • ltag 为 0 时指向该结点的左孩子，为 1 时指向该结点的前驱

  • rtag 为 0 时指向该结点的右孩子，为 1 时指向该结点的后继

  • 

  • 代码——二叉树的线索存储结构定

    /* 二叉树的二叉线索存储结构定义 */
    typedef enum {Link,Thread} PointerTag; /* Link==0 表示指向左右孩子指针 Thread == 1 表示指向前驱或后继的线索 */
    typedef struct BiThrNode /* 二叉线索存储结点结构 */
    {
      TElemType data; /* 结点数据 */
      struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
      PointerTag LTag;
      PointerTag RTag; /* 左右标志 */
    } BiThrNode, *BiThrTree;
    

• 线索化的过程就是在遍历的过程中修改空指针的过程
• 如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

五、树、森林与二叉树的转换

1、树转换为二叉树

• 加线。在所有兄弟结点之间加一条连线。
• 去线。对树中每个结点，只保留它与第一个孩子结点的连线，删除它与其他孩子结点之间的连线。
• 层次调整。以树的根结点为轴心，将整棵树顺时针旋转一定的角度，使之结构层次分明。注意第一个孩子是二叉树结点的左孩子，兄弟转换过来的孩子是结点的右孩子

2、森林转换为二叉树

• 把每个树转换为二叉树。
• 第一棵二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子，用线连接起来。当所有的二叉树连接起来后就得到了由森林转换来的二叉树

3、二叉树转换为树

• 加线。左孩子的 n 个右孩子结点都作为此结点的孩子。将该结点与这些右孩子结点用线连接起来
• 去线。删除原二叉树中所有结点与其右孩子结点的连线。
• 层次调整。使之结构层次分明。

4、二叉树转换为森林

• 从根结点开始，若右孩子存在，则把与右孩子结点的连线删除，再查看分离后的二叉树，若右孩子存在，则连线删除……，直到所有右孩子连线都删除为止，得到分离的二叉树
• 再将每棵分离后的二叉树转换为树即可。

5、树与森林的遍历

• 树的遍历分为两种方式
  • 先根遍历树，即先访问树的根结点，然后依次先根遍历根的每棵子树
  • 后根遍历，即先依次后根遍历每棵子树，然后再访问根结点
• 森林的遍历分为两种方式
  • 前序遍历：先访问森林中第一棵树的根结点，然后再依次先根遍历根的每棵子树，再依次用同样方式遍历除去第一棵树的剩余树构成的森林。
  • 后序遍历：先访问森林中第一棵树，后根遍历的方式遍历每棵子树，然后再访问根结点，再依次同样方式遍历除去第一棵树的剩余树构成的森林

六、赫夫曼树

• 从树中一个结点到另一个结点之间的分支构成两个结点之间的路径，路径上的分支数目称做路径长度。
• 树的路径长度就是从树根到每一结点的路径长度之和。
• 如果考虑到带权的结点，结点的带权的路径长度为从该结点到树根之间的路径长度与结点上权的乘积。树的带权路径长度为树中所有叶子结点的带权路径长度之和。带权路径长度 WPL 最小的二叉树称做赫夫曼树。

1、构造赫夫曼树

• 1. 根据给定的n 个权值$W_1,W_2,\dots ,W_n$构成n 棵二叉树的集合$F=T_1,T_2,\dots ,T_n$,其中每棵二叉树$T_i$中只有一个带权为 $W_i$ 根结点，其左右子树均为空。
• 2. 在 F 中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树，且置新的二叉树的根结点的权值为其左右子树上根结点的权值之和。
• 3. 在 F 中删除这两棵树，同时将新得到的二叉树加入 F 中。
• 4. 重复 2 和 3 步骤，直到 F 只含一棵树为止。这棵树便是赫夫曼树

2、赫夫曼编码

目的是为了解决当年远距离通信（主要是电报）的数据传输的最优化问题。
编码中非 0 即 1, 长短不等的话其实是很容易混淆的，所以若要设计长短不等的编码，则必须是任一字符的编码都不是另一个字符的编码的前缀，这种编码称做前缀编码。
一般地，设需要编码的字符集为$d_1,d_2,\dots ,d_n$, 各个字符在电文中出现的次数或频率集合为$W_1,W_2,\dots ,W_n$, 以 $d_1,d_2,\dots ,d_n$作为叶子结点，以 $W_1,W_2,\dots ,W_n$ 作为相应叶子结点的权值来构造一棵赫夫曼树。规定赫夫曼树的左分支代表 0, 右分支代表 1,则从根结点到叶子结点所经过的路径分支组成的 0 和1 的序列便为该结点对应字符的编码，这就是赫夫曼编码。