5 树

1 树

1.1 树的定义

• 树(Tree)是n(n>=0)个结点的有限集。

  当n=0时成为空树，在任意一棵非空树中：有且仅有一个特定的称为根(Root)的结点；
  当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、…、Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree)。

  

• 结点和度

  每一个圈圈我们就称为树的一个结点。结点拥有的子树数称为结点的度-(Degree)，树的度取树内各结点的度的最大值。

  • 度为0的结点称为叶结点(Leaf)或终端结点；
  • 度不为0的结点称为分支结点或非终端结点，除根结点外，分支结点也称为内部结点。

  

• 双亲、孩子、兄弟、祖先

  结点的子树的根称为结点的孩子(Child)，相应的，该结点称为孩子的双亲(Parent)，同一双亲的孩子之间互称为兄弟(Sibling)。结点的祖先是从根到该结点所经分支上的所有结点。

• 结点的层次

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

  • 其双亲在同一层的结点互为堂兄弟。

  • 树中结点的最大层次称为树的深度(Depth)或高度。

1.2 树的存储结构

双亲表示法、孩子表示法、孩子兄弟表示法。

略

2 二叉树

2.1 二叉树的定义

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

2.2 二叉树的特点

每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。（注意：不是都需要两棵子树，而是最多可以是两棵，没有子树或者有一棵子树也都是可以的。）

左子树和右子树是有顺序的，次序不能颠倒。

即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。

2.3 二叉树的五种基本形态

2.4 特殊二叉树

2.4.1 斜树

2.4.2 满二叉树

在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。

• 满二叉树的特点

  • 叶子只能出现在最下一层。

  • 非叶子结点的度一定是2。

  • 在同样深度的二叉树中，满二叉树的结点个数一定最多，同时叶子也是最多。

2.4.3 完全二叉树

对一棵具有n个结点的二叉树按层序编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点位置完全相同，则这棵二叉树称为完全二叉树。

• 完全二叉树的特点

  • 叶子结点只能出现在最下两层。

  • 最下层的叶子一定集中在左部连续位置。

  • 倒数第二层，若有叶子结点，一定都在右部连续位置。

  • 如果结点度为1，则该结点只有左孩子。

  • 同样结点树的二叉树，完全二叉树的深度最小。

满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。

• 完全二叉树判断

  可以在满二叉树上顺序标明数字，然后去掉结点后数字依然连续就是完全二叉树。

  • 不是完全二叉树的例子

    

    

    

• 二叉树的性质

  • 性质一：在二叉树的第i层上至多有2^(i-1)个结点(i>=1)，，，画出二叉树的图便可以推出

  • 性质二：深度为k的二叉树至多有2^k-1个结点(k>=1)

  • 性质三：对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1

    • 首先我们再假设度为1的结点数为n1，则二叉树T的结点总数n=n0+n1+n2
      其次我们发现连接数总是等于总结点数n-1，并且等于n1+2*n2
      所以n-1=n1+2*n2
      所以n0+n1+n2-1=n1+n2+n2
      最后n0=n2+1

  • 性质四：具有n个结点的完全二叉树的深度为⌊log₂n⌋+1 （向下取整符号）

  • 性质五：如果对一棵有n个结点的完全二叉树(其深度为⌊log₂n⌋+1)的结点按层序编号，对任一结点i(1<=i<=n)有以下性质：

    • 如果i = 1，则结点 i 是二叉树的根，无双亲；如果i > 1，则其双亲是结点⌊i/2⌋

    • 如果2i > n，则结点 i 无左孩子(结点 i 为叶子结点)；否则其左孩子是结点2i

    • 如果2i+1 > n，则结点 i 无右孩子；否则其右孩子是结点2i+1

2.5 二叉树的存储结构

2.5.1 二叉树的顺序存储结构

二叉树的顺序存储结构就是用一维数组存储二叉树中的各个结点，并且结点的存储位置能体现结点之间的逻辑关系。

对于一般的二叉树，把不存在的结点用“^”代替即可。

2.5.1 二叉树的链式存储结构

顺序存储结构对于斜树存储效率不高，考虑链式存储结构。二叉树的存储按照国际惯例来说一般也是采用链式存储结构的。

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

• 结构定义代码

typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

2.6 二叉树的遍历

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

限制了从左到右的习惯方式，二叉树的遍历方式主要分为一下四种：

• 前序遍历

• 中序遍历

• 后序遍历

• 层序遍历

2.6.1 二叉树的前序遍历

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

遍历的顺序为：ABDHIEJCFKG

2.6.2 二叉树的中序遍历

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

遍历的顺序为：HDIBEJAFKCG

2.6.3 二叉树的后序遍历

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

遍历的顺序为：HIDJEBKFGCA

2.6.4 二叉树的层序遍历

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

遍历的顺序为：ABCDEFGHIJK

2.7 二叉树的建立和遍历算法

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

// 创建一颗二叉树，约定用户遵照前序遍历的方式输入数据
CreateBiTree(BiTree *T)
{
    char c;

    scanf("%c", &c);
    if( ' ' == c )
    {
        *T = NULL;
    }
    else
    {
        *T = (BiTNode *)malloc(sizeof(BiTNode));
        (*T)->data = c;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}

// 访问二叉树结点具体操作
visit(char c, int level)
{
    printf("%c 位于第 %d 层\n", c, level);
}

// 二叉树遍历
PreOrderTraverse(BiTree T, int level)
{
    if( T )
    {
        visit(T->data, level);
        PreOrderTraverse(T->lchild, level+1);
        PreOrderTraverse(T->rchild, level+1);
    }
}

int main()
{
    int level = 1;
    BiTree T = NULL;

    CreateBiTree(&T);
    PreOrderTraverse(T, level);

    return 0;
}

2.8 线索二叉树

普通的二叉树到底有什么缺陷？

“^”浪费时间，浪费空间

采用中序遍历节省时间和空间

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;

// 线索存储标志位
// Link(0)：表示指向左右孩子的指针
// Thread(1)：表示指向前驱后继的线索
typedef enum {Link, Thread} PointerTag;

typedef struct BiThrNode
{
    char data;
    struct BiThrNode *lchild, *rchild;
    PointerTag ltag;
    PointerTag rtag;
} BiThrNode, *BiThrTree;

// 全局变量，始终指向刚刚访问过的结点
BiThrTree pre;

// 创建一棵二叉树，约定用户遵照前序遍历的方式输入数据
void CreateBiThrTree( BiThrTree *T )
{
    char c;

    scanf("%c", &c);
    if( ' ' == c )
    {
        *T = NULL;
    }
    else
    {
        *T = (BiThrNode *)malloc(sizeof(BiThrNode));
        (*T)->data = c;
        (*T)->ltag = Link;
        (*T)->rtag = Link;

        CreateBiThrTree(&(*T)->lchild);
        CreateBiThrTree(&(*T)->rchild);
    }
}

// 中序遍历线索化
void InThreading(BiThrTree T)
{
    if( T )
    {
        InThreading( T->lchild );       // 递归左孩子线索化

        if( !T->lchild )    // 如果该结点没有左孩子，设置ltag为Thread，并把lchild指向刚刚访问的结点。
        {
            T->ltag = Thread;
            T->lchild = pre;
        }

        if( !pre->rchild )
        {
            pre->rtag = Thread;
            pre->rchild = T;
        }

        pre = T;

        InThreading( T->rchild );       // 递归右孩子线索化
    }
}

void InOrderThreading( BiThrTree *p, BiThrTree T )
{
    *p = (BiThrTree)malloc(sizeof(BiThrNode));
    (*p)->ltag = Link;
    (*p)->rtag = Thread;
    (*p)->rchild = *p;
    if( !T )
    {
        (*p)->lchild = *p;
    }
    else
    {
        (*p)->lchild = T;
        pre = *p;
        InThreading(T);
        pre->rchild = *p;
        pre->rtag = Thread;
        (*p)->rchild = pre;
    }
}

void visit( char c )
{
    printf("%c", c);
}

// 中序遍历二叉树，非递归
void InOrderTraverse( BiThrTree T )
{
    BiThrTree p;
    p = T->lchild;

    while( p != T )
    {
        while( p->ltag == Link )
        {
            p = p->lchild;
        }
        visit(p->data);

        while( p->rtag == Thread && p->rchild != T )
        {
            p = p->rchild;
            visit(p->data);
        }

        p = p->rchild;
    }
}

int main()
{
    BiThrTree P, T = NULL;

    CreateBiThrTree( &T );

    InOrderThreading( &P, T );

    printf("中序遍历输出结果为: ");

    InOrderTraverse( P );

    printf("\n");

    return 0;
}