大话数据结构 －－ 树

一整天停停看看终于把树这一章看完了，要记忆和理解的东西有点多，写篇博客总结下。。。

咳咳，下面是正题。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

树的定义

树是n(n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中：

1、有且只有一个特定的称为根（Root）的结点；

2、当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1、T2、......、Tm，其中每一个集合本身又是一棵树，并且称为根的子树。

可以看出，树的定义其实用到了递归的方法（即树的定义中还用到了树的概念，这是一种比较新的定义方法）。

 

结点分类

树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度（Degree）。

1、叶结点／终端结点：度为0；

2、分支结点／非终端结点：度不为0。

除根结点外，分支结点也称为内部结点。

树的度是树内各结点的度的最大值。

 

结点间关系

1、结点的子树的根称为该结点的孩子，相应地，该结点称为孩子的双亲；

2、同一个双亲的孩子之间互称兄弟；

3、结点的祖先是从根到该结点所经分支上的所有结点；

4、以某结点为根的子树中的任一结点都称为该结点的子孙。

 

结点的层次

1、根结点为第一层；

2、若某结点在第i层，则其子树就在第i+1层；

3、双亲在同一层的结点互为堂兄弟；

4、树中结点的最大层次称为树的深度或高度；（注意与 度 的概念区分）

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

6、森林是m棵互不相交的树的集合，对树中每个结点而言，其子树的集合即为森林。

 

树的表示

1、双亲表示法

除了根结点外，其余每个结点不一定有孩子，但一定有且仅有一个双亲。

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

// 树的双亲表示法结点结构定义
#define MAX_TREE_SIZE 100
// 树结点的数据类型，目前暂定为整型
typedef int TElemmType;

//结点结构
typedef struct PTNode{
    // 结点数据
    TElemType data;
    // 双亲位置
    int parent;
}PTNode;

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

1）、由于根结点是没有双亲的，所以我们约定根结点的位置域设置为-1，这也就意味着，我们所有的结点都存有它双亲的位置；

2）、我们可以根据结点的parent指针很容易找到它的双亲结点，所用的时间复杂度为O(1)，直到parent为-1时，表示找到了树结点的根。可是如果我们要知道结点的孩子是什么，要遍历整个结构才行；（看谁的双亲结点是这个结点，谁就是这个结点的孩子）

3）、为了改进上述查找孩子结点的麻烦，我们增加一个结点最左边孩子的域，叫它长子域（firstchild）。如果结点没有孩子，这个长子域就设置为-1；

4）、双亲表示法无法体现兄弟之间的关系——我们可以增加一个右兄弟域来体现兄弟关系。如果右兄弟不存在，则赋值为-1。

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

2、孩子表示法

每个结点有多个指针域，其中每个指针指向一颗子树的根结点，我们把这种方法叫做多重链表表示法。但是，树的每个结点的度，也就是它的孩子个数是不同的。所以可以设计两种方案来解决。

1）、一种是指针域的个数就等于树的度（树各个结点度的最大值）；

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

既然很多指针域可能为空，为什么不按需分配空间呢？⬇️

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

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

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、孩子兄弟表示法

任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。

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

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

当然，如果想找某个结点的双亲，这个表示法也是有缺陷的。如果真的有必要，可以再增加一个parent指针域来解决快速查找双亲的问题。

其实，这个表示法最大的好处是它把一棵复杂的树变成了一棵二叉树。我们把图6-4-6变变形就成了下图这个样子：

这样就可以充分利用二叉树的特性和算法来处理这棵树了。

 

二叉树的特点

1、每个结点最多有两棵子树；

2、左子树和右子树是有顺序的，次序不能任意颠倒；

3、即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。如图6-5-3，树1和树2是同一棵树，但它们却是不同的二叉树；

4、二叉树有五种基本形态：1）空二叉树；2）只有一个根结点；3）根结点只有左子树；4）根结点只有右子树；5）根结点既有左子树又有右子树。

比如，如果是有三个结点的树，有2种形态；而如果是有三个结点的二叉树，有5种形态。

 

特殊二叉树

1、斜树

所有的结点都只有左子树的二叉树叫左斜树；所有结点都只有右子树的二叉树叫右斜树。这两者统称为斜树。

斜树每一层都只有一个结点，结点的个数和二叉树的深度相同。

由此也可以看出，其实线性表结构就可以理解为是树的一种极其特殊的表现形式（斜树）。

2、满二叉树

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

注意：但是每个分支结点都存在左右子树，不能算是满二叉树，还必须要所有的叶子在同一层上。

特点：

1）、叶子只能出现在最下一层，出现在其他层就不可能达成平衡；

2）、非叶子结点的度一定是2；

3）、在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多。

3、完全二叉树

如果编号为i（1<=i<=n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同。则这棵树称为完全二叉树。

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

特点：

1）、叶子只能出现在最下两层；

2）、最下层的叶子结点一定集中在左部连续位置；

3）、倒数二层，若有叶子结点，一定都在右部连续位置；

4）、如果结点度为1，则该结点只有左孩子，即不存在只有右子树的情况；

5）、同样结点数的二叉树，完全二叉树的深度最小。

 

二叉树的性质

1、在二叉树的第i层上至多有2^(i-1)个结点；

2、深度为k的二叉树至多有2^k-1个结点（k>=1）；

3、对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1；

终端结点树其实就是叶子结点树，而一棵二叉树，除了叶子结点外，剩下的就是度为1或2的结点数了，故n=n0+n1+n2;

由于根结点只有分支进去，没有分支进入，所以分支线总数为结点总数减去1，即n-1=n1+2*n2;

4、具有n个结点的完全二叉树的深度为|log2(n)+1|（|x|表示不大于x的最大整数）

假设其深度为k，则它的结点数一定小于等于同样深度的满二叉树的结点数，即n<=2^k-1；同时，一定大于比它少一层的满二叉树的结点数，即n>2^(k-1)-1；因为n是一个整数，所以2^(k-1)<=n<2^k；两边同时取对数得k-1<=log2(n)<=k；而k作为深度也是整数，因此k=|log2(n)|+1。

5、如果对一棵有n个结点的完全二叉树的结点按层序编号，对任一结点i（1<=i<=n）有：

1）、如果i＝1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是结点；

2）、如果2i>n，则结点i无左孩子（结点i为叶子结点）；否则其左孩子是结点2i；

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

 

二叉树的存储结构

1、顺序存储结构

二叉树是一种特殊的树，由于它的特殊性，使得用顺序存储结构也可以实现。

二叉树的顺序存储结构就是用一维数组存储二叉树中的结点。

如果树是一棵完全二叉树，效果当然很好，但考虑一种极端情况：一棵深度为k的右斜树，它只有k个结点，却需要分配2^k-1个存储单元空间，这显然是对存储空间的浪费。所以，顺序存储结构一般只适用于完全二叉树。

2、二叉链表

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

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

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

 

二叉树遍历方法

树的结点之间不存在唯一的前驱和后继关系，在访问一个结点后，下一个被访问的结点面临着不同的选择。

1、前序遍历

若二叉树为空，则空操作返回；否则根左右顺序访问结点；

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

2、中序遍历

若二叉树为空，则空操作返回；否则左根右顺序访问结点；

// 二叉树的中序遍历递归算法
void InOrderTraverse(BiTree T){
	if(T==NULL)
		return;
	// 中序遍历左子树
	InOrderTraverse(T->lchild);
	printf("%c",T->data);
	InOrderTraverse(T->rchild);

}

3、后序遍历

若二叉树为空，则空操作返回；否则左右根顺序访问结点；

// 二叉树的后序遍历递归算法
void PostOrderTraverse(BiTree T){
	if(T==NULL)
		return;
	PostOrderTraverse(T->lchild);
	PostOrderTraverse(T->rchild);
	printf("%c",T->data);
}

4、层序遍历

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

这四种遍历方法，其实都是在把树中的结点变成某种意义的线性序列。

5、推导遍历

推导遍历即可根据序列画出二叉树后再求解，也可以用一些小技巧：

1）、前序遍历中第一个遍历的数据肯定是根结点；

2）、中序遍历以根结点为分界，可以区分左子树和右子树；

3）、后续遍历最后一个遍历的数据肯定是根结点；

4）、已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；

5）、已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树；

6）、但是，已知前序遍历序列和后序遍历序列，是不能确定一棵二叉树的。

 

二叉树的建立

扩展二叉树：将二叉树中每个结点的空指针引出一个虚结点，其值为一特定值，比如“＃”。

// 按前序输入二叉树中结点的值（一个字符）
// #表示空树，构造二叉链表表示二叉树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);
       ｝
｝

其实建立二叉树也利用了递归的原理。

 

线索二叉树

二叉链表有一些缺陷：

1、对于一个有n个结点二叉链表，每个结点有指向左右孩子的两个指针域，所以一共是2n个指针域。而n个结点的二叉树一共有n-1条分支线数，也就是说，其实是存在2n-(n-1)=n+1个空指针域。

2、在二叉链表上，我们只能知道每个结点指向其左右孩子结点的地址，而不知道某个结点的前驱是谁，后继是谁。要想知道，必须遍历一次。

考虑到以上两个角度，我们可以利用那些空地址，存放指向结点在某种遍历次序下的前驱和后继结点的地址。

我们把这种指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树。

1、将所有的空指针域中的rchild，改为指向它的后继结点；

2、将所有空指针域中的lchild，改为指向当前结点的前驱。

其实线索二叉树，等于是把一棵二叉树转变成了一个双向链表，这样对我们的插入删除结点、查找某个结点都带来了方便。

我们把对二叉树以某种次序遍历使其成为线索二叉树的过程称作是线索化。

在每个结点再增设两个标志域ltag和rtag，它们是存放0或1数字的布尔型变量，其占用的内存空间要小于像lchild和rchild的指针变量。

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

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

线索化的实质就是将二叉链表中的空指针改为指向前驱或后继的线索。由于前驱和后继的信息只有在遍历该二叉树时才能得到，所以线索化的过程就是在遍历的过程中修改空指针的过程。

#include "string.h"
#include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef char TElemType;
typedef enum {Link,Thread} PointerTag;	/* Link==0表示指向左右孩子指针, */
/* Thread==1表示指向前驱或后继的线索 */
typedef  struct BiThrNode	/* 二叉线索存储结点结构 */
{
    TElemType data;	/* 结点数据 */
    struct BiThrNode *lchild, *rchild;	/* 左右孩子指针 */
    PointerTag LTag;
    PointerTag RTag;		/* 左右标志 */
} BiThrNode, *BiThrTree;

TElemType Nil='#'; /* 字符型以空格符为空 */

Status visit(TElemType e)
{
    printf("%c ",e);
    return OK;
}

/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{
    TElemType h;
    scanf("%c",&h);
    
    if(h==Nil)
        *T=NULL;
    else
    {
        *T=(BiThrTree)malloc(sizeof(BiThrNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data=h; /* 生成根结点(前序) */
        CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
        if((*T)->lchild) /* 有左孩子 */
            (*T)->LTag=Link;
        CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
        if((*T)->rchild) /* 有右孩子 */
            (*T)->RTag=Link;
    }
    return OK;
}

BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
/* 中序遍历进行中序线索化 */
void InThreading(BiThrTree p)
{
    if(p)
    {
        InThreading(p->lchild); /* 递归左子树线索化 */
        if(!p->lchild) /* 没有左孩子 */
        {
            p->LTag=Thread; /* 前驱线索 */
            p->lchild=pre; /* 左孩子指针指向前驱 */
        }
        if(!pre->rchild) /* 前驱没有右孩子 */
        {
            pre->RTag=Thread; /* 后继线索 */
            pre->rchild=p; /* 前驱右孩子指针指向后继(当前结点p) */
        }
        pre=p; /* 保持pre指向p的前驱 */
        InThreading(p->rchild); /* 递归右子树线索化 */
    }
}

/* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{
    *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
    if(!*Thrt)
        exit(OVERFLOW);
    (*Thrt)->LTag=Link; /* 建头结点 */
    (*Thrt)->RTag=Thread;
    (*Thrt)->rchild=(*Thrt); /* 右指针回指 */
    if(!T) /* 若二叉树空,则左指针回指 */
        (*Thrt)->lchild=*Thrt;
    else
    {
        (*Thrt)->lchild=T;
        pre=(*Thrt);
        InThreading(T); /* 中序遍历进行中序线索化 */
        pre->rchild=*Thrt;
        pre->RTag=Thread; /* 最后一个结点线索化 */
        (*Thrt)->rchild=pre;
    }
    return OK;
}

/* 中序遍历二叉线索树T(头结点)的非递归算法 */
Status InOrderTraverse_Thr(BiThrTree T)
{
    BiThrTree p;
    p=T->lchild; /* p指向根结点 */
    while(p!=T)
    { /* 空树或遍历结束时,p==T */
        while(p->LTag==Link)
            p=p->lchild;
        if(!visit(p->data)) /* 访问其左子树为空的结点 */
            return ERROR;
        while(p->RTag==Thread&&p->rchild!=T)
        {
            p=p->rchild;
            visit(p->data); /* 访问后继结点 */
        }
        p=p->rchild;
    }
    return OK;
}

int main()
{
    BiThrTree H,T;
    printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
    CreateBiThrTree(&T); /* 按前序产生二叉树 */
    InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */
    printf("中序遍历(输出)二叉线索树:\n");
    InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
    printf("\n");
    
    return 0;
}

线索二叉树充分利用了空指针域的空间（这等于节省了空间），又保证了创建时的一次遍历就可以终生受用前驱后继的信息（这意味着节省了时间）。所以在实际问题中，如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

 

树、森林与二叉树的转换

1、树转换为二叉树

1）、加线。在所有兄弟结点之间加一条连线；

2）、去线。对树中每个结点，只保留它与第一个孩子结点的连线，删除它与其他孩子结点之间的连线；

3）、层次调整。以树的根结点为轴心，将整棵树顺时针旋转一定的角度，使之结构层次分明。注意第一个孩子是二叉树结点的左孩子，兄弟转换过来的孩子是结点的右孩子。

2、森林转换为二叉树

1）、把每个树转换为二叉树；

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

3、二叉树转换为树

1）、加线。左孩子的n个右孩子结点都作为此结点的孩子。将该结点与这些右孩子结点用线连接起来；

2）、去线。删除原二叉树中所有结点与其右孩子结点的连线；

3）、层次调整。使之结构层次分明。

 

树与森林的遍历

树的遍历分为两种方式：

1、先根遍历树：即先访问树的根结点，然后依次先根遍历根的每棵子树；

2、后根遍历树：即先依次先根遍历每棵子树，然后访问根结点。

森林的遍历也分为两种方式：

1、前序遍历：先访问森林中第一棵树的根结点，然后再依次先根遍历根的每棵子树，再依次用同样方式遍历除去第一棵树的剩余树构成的森林；

2、后序遍历：先访问森林中第一棵树，后根遍历的方式遍历每棵子树，然后再访问根结点，再依次同样方式遍历除去第一棵树的剩余树构成的森林。

 

赫夫曼树

从树中一个结点到另一个结点之间的分支构成两个结点之间的路径，路径上的分支数目称做路径长度。

结点的带权路径长度为从该结点到树根之间的路径长度与结点上权的乘积。

带权路径长度WPL最小的二叉树称做赫夫曼树，也称为最优二叉树。