数据结构 - 树

郝斌版《数据结构》学习笔记

时间：2015.08.31 - 2015.09.05

定义：

        专业定义：有且只有一个称为根的节点，有若干个互不相交的子树，这些子树本身也是一棵树。

        通俗定义：树是由节点和边（指针域）组成；

                         每个节点只有一个父节点但可以有多个子节点；

                         有一个节点例外，该节点没有父节点，此节点称为根节点。

        节点（具体的事物实例）    根节点（第一层）    父节点    子节点    深度（树中节点的最大层次，从根节点到最底层节点的层数）

        叶子节点（没有子节点的节点）    非终端节点（非叶子节点）

        度（子节点的个数）（树的度：最大的度）

分类：

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

        二叉树：任意一个节点的子节点的个数最多有两个，且子节点的位置不可更改（1是左子树，2是右子树），二叉树是有序树。

                分类：一般二叉树

                           满二叉树（深度为k节点数为2k-1，不增加树的层数的前提下，无法再多添加一个节点的二叉树）

                           完全二叉树（如果只是删除了满二叉树最底层最右边连续若干个节点形成的二叉树，就是完全二叉树）

               满二叉树是完全二叉树的一个特例，最底层最右边的一个都不删。

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

树的存储：

        二叉树的存储：

                连续存储[完全二叉树]

满二叉树：

完全二叉树：

先序：A B C D E F

中序：C B E D F A

后序：

以仅有的节点作为数组存储（先序、中序排法不同），他人无法还原二叉树的排列，不能再去存储。

完全二叉树的优点：

                            深度知道

                            查找子节点、父节点很方便（包括判断有没有子节点）

                    缺点：

                            耗用内存空间过大

链式存储

指针域，左右指针，没有的则为空^(NULL)

简单，耗用内存少

                一般树的存储

                        双亲表示法

                               求父节点方便（数组）

                        孩子表示法

                                求子节点方便（链表）

                        双亲孩子表示法

A B C D E F节点顺序随便写（数组+链表）

求父节点、子节点都很方便。

                        二叉树表示法

把一个普通树转化成二叉树来存储

具体转换方法：

        设法保证任意一个节点的

                左指针域指向它的第一个孩子

                右指针域指向它的兄弟

        只要能满足此条件，就可以把一个普通树转化为二叉树。

一个普通树转化成的二叉树，一定没有右子树。（指向它下一个兄弟）

                森林的存储

先把森林转化为二叉树，再存储二叉树。

二叉树操作：

        遍历（递归访问）

                先序遍历【先访问根节点】

                        先访问根节点，

                        再先序访问左子树，

                        再先序访问右子树。

线性：任何一个点前面都有一个点，后面也有一个点，顺序是确定的。

                中序遍历【中间访问根节点】

                        中序遍历左子树

                        再访问根节点

                        再中序遍历右子树

                后序遍历【最后访问根节点】

                        后序遍历左子树

                        再后序遍历右子树

                        再访问根节点

                已知两种遍历序列求原始二叉树

通过先序和中序，或中序和后序我们可以还原出原始的二叉树，但是通过先序和后序，或者只有一种顺序我们是无法还原出原始的二叉树（即唯一确定的二叉树）。

遍历，先中或中后，需要两种（包含中序）才能推出来。

左指针域（4个字节），数值域（可能含大量数据），右指针域（4个字节）

# include <stdio.h>

# include <malloc.h>

struct BTNode

{

 int data;

 struct BTNode * pLchild; //p是指针，L是左，child是孩子

 struct BTNode * pRchild;

};

struct BTNode * CreateBTree();

void PreTraverseBTree(struct BTNode *);

void InTraverseBTree(struct BTNode *);

void PostTraverseBTree(struct BTNode *);

int main(void)

{

 //静态

 struct BTNode * pT = CreateBTree(); //create链式二叉树，只返回根节点的地址（4个字节），节省空间

 printf("先序遍历为：\n");

 PreTraverseBTree(pT);

 printf("\n");

 printf("中序遍历为：\n");

 InTraverseBTree(pT);

 printf("\n");

 printf("后序遍历为：\n");

 PostTraverseBTree(pT);

 printf("\n");

 return 0;

}

void PreTraverseBTree(struct BTNode * pT) //先序

{

 //先访问根节点

 //再先序访问左子树

 //再先序访问右子树

 if (NULL != pT)

 {

  printf("%c ", pT->data);

  if (NULL != pT->pLchild) //递归很浪费时间和内存

  {

   PreTraverseBTree(pT->pLchild);

  }

  if (NULL != pT->pRchild)

  {

   PreTraverseBTree(pT->pRchild); //pT->pLchild可以代表整个左子树

  }

 }

}

void InTraverseBTree(struct BTNode * pT) //中序

{

 //先访问根节点

 //再先序访问左子树

 //再先序访问右子树

 if (NULL != pT)

 {

  if (NULL != pT->pLchild) //先中序遍历左子树

  {

   PreTraverseBTree(pT->pLchild);

  }

  printf("%c ", pT->data); //再访问根

  if (NULL != pT->pRchild) //最后中序遍历右子树

  {

   PreTraverseBTree(pT->pRchild); //pT->pLchild可以代表整个左子树

  }

 }

}

void PostTraverseBTree(struct BTNode * pT) //后序

{

 //先访问根节点

 //再先序访问左子树

 //再先序访问右子树

 if (NULL != pT)

 {

  if (NULL != pT->pLchild) //先中序遍历左子树

  {

   PreTraverseBTree(pT->pLchild);

  }

 

  if (NULL != pT->pRchild) //再中序遍历右子树

  {

   PreTraverseBTree(pT->pRchild); //pT->pLchild可以代表整个左子树

  }

  printf("%c ", pT->data); //最后访问根

 }

}

//静态造一个二叉树，若需要动态create,则需要递归来实现

/*

 创建链表二叉树，需要注意三点：

  第一，形参是指向结构体变量的指针的指针。

  第二，我们假定输入零表示该节点为空。

  第三，我们是以先序的顺序来创建二叉树的，但问题是无论以先序还是中序或者后序，我们都无法唯一确定该二叉树，解决的办法是

  “我们必须把那些节点为空的值也以先序或是中序或者后序的顺序来输入，这样就可以唯一确定该二叉树了”。满二叉树

*/

struct BTNode * CreateBTree(void)

{

 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->pLchild = pB;

 pA->pRchild = pC;

 pB->pLchild = pB->pRchild = NULL;

 pC->pLchild = pD;

 pC->pRchild = NULL;

 pD->pLchild = NULL;

 pD->pRchild = pE;

 pE->pLchild = pE->pRchild = NULL;

 return pA; //返回根节点数

}

应用：

        树是数据库中数据组织的一种重要形式。

        操作系统子父进程的关系本身就是一棵树。

        面向对象语言中类的继承关系。

        赫夫曼树

以下转载自：http://www.cnblogs.com/fzhe

二叉树前序、中序、后序遍历相互求法

今天来总结下二叉树前序、中序、后序遍历相互求法，即如果知道两个的遍历，如何求第三种遍历方法，比较笨的方法是画出来二叉树，然后根据各种遍历不同的特性来求，也可以编程求出，下面我们分别说明。

首先，我们看看前序、中序、后序遍历的特性： 
前序遍历： 
    1.访问根节点 
    2.前序遍历左子树 
    3.前序遍历右子树 
中序遍历： 
    1.中序遍历左子树 
    2.访问根节点 
    3.中序遍历右子树 
后序遍历： 
    1.后序遍历左子树 
    2.后序遍历右子树 
    3.访问根节点

一、已知前序、中序遍历，求后序遍历

例：

前序遍历:         GDAFEMHZ

中序遍历:         ADEFGHMZ

画树求法：
第一步，根据前序遍历的特点，我们知道根结点为G

第二步，观察中序遍历ADEFGHMZ。其中root节点G左侧的ADEF必然是root的左子树，G右侧的HMZ必然是root的右子树。

 第三步，观察左子树ADEF，左子树的中的根节点必然是大树的root的leftchild。在前序遍历中，大树的root的leftchild位于root之后，所以左子树的根节点为D。

第四步，同样的道理，root的右子树节点HMZ中的根节点也可以通过前序遍历求得。在前序遍历中，一定是先把root和root的所有左子树节点遍历完之后才会遍历右子树，并且遍历的左子树的第一个节点就是左子树的根节点。同理，遍历的右子树的第一个节点就是右子树的根节点。

第五步，观察发现，上面的过程是递归的。先找到当前树的根节点，然后划分为左子树，右子树，然后进入左子树重复上面的过程，然后进入右子树重复上面的过程。最后就可以还原一棵树了。该步递归的过程可以简洁表达如下：

1 确定根,确定左子树，确定右子树。

2 在左子树中递归。

3 在右子树中递归。

4 打印当前根。

那么，我们可以画出这个二叉树的形状：

那么，根据后序的遍历规则，我们可以知道，后序遍历顺序为：AEFDHZMG

编程求法：（依据上面的思路，写递归程序）

 1 #include <iostream>  
 2 #include <fstream>  
 3 #include <string>  
 4 
 5 struct TreeNode
 6 {
 7   struct TreeNode* left;
 8   struct TreeNode* right;
 9   char  elem;
10 };
11 
12 void BinaryTreeFromOrderings(char* inorder, char* preorder, int length)
13 {
14   if(length == 0)
15     {
16       //cout<<"invalid length";
17       return;
18     }
19   TreeNode* node = new TreeNode;//Noice that [new] should be written out.
20   node->elem = *preorder;
21   int rootIndex = 0;
22   for(;rootIndex < length; rootIndex++)
23     {
24       if(inorder[rootIndex] == *preorder)
25       break;
26     }
27   //Left
28   BinaryTreeFromOrderings(inorder, preorder +1, rootIndex);
29   //Right
30   BinaryTreeFromOrderings(inorder + rootIndex + 1, preorder + rootIndex + 1, length - (rootIndex + 1));
31   cout<<node->elem<<endl;
32   return;
33 }
34 
35 
36 int main(int argc, char* argv[])
37 {
38     printf("Hello World!\n");
39     char* pr="GDAFEMHZ";
40     char* in="ADEFGHMZ";
41   
42     BinaryTreeFromOrderings(in, pr, 8);
43 
44     printf("\n");
45     return 0;
46 }

输出的结果为：AEFDHZMG

二、已知中序和后序遍历，求前序遍历

依然是上面的题，这次我们只给出中序和后序遍历：

中序遍历:       ADEFGHMZ

后序遍历:       AEFDHZMG

画树求法：
第一步，根据后序遍历的特点，我们知道后序遍历最后一个结点即为根结点，即根结点为G。

第二步，观察中序遍历ADEFGHMZ。其中root节点G左侧的ADEF必然是root的左子树，G右侧的HMZ必然是root的右子树。

第三步，观察左子树ADEF，左子树的中的根节点必然是大树的root的leftchild。在前序遍历中，大树的root的leftchild位于root之后，所以左子树的根节点为D。

第四步，同样的道理，root的右子树节点HMZ中的根节点也可以通过前序遍历求得。在前后序遍历中，一定是先把root和root的所有左子树节点遍历完之后才会遍历右子树，并且遍历的左子树的第一个节点就是左子树的根节点。同理，遍历的右子树的第一个节点就是右子树的根节点。

第五步，观察发现，上面的过程是递归的。先找到当前树的根节点，然后划分为左子树，右子树，然后进入左子树重复上面的过程，然后进入右子树重复上面的过程。最后就可以还原一棵树了。该步递归的过程可以简洁表达如下：

1 确定根,确定左子树，确定右子树。

2 在左子树中递归。

3 在右子树中递归。

4 打印当前根。

这样，我们就可以画出二叉树的形状，如上图所示，这里就不再赘述。

那么，前序遍历:         GDAFEMHZ

编程求法：（并且验证我们的结果是否正确）

#include <iostream>
#include <fstream>
#include <string>

struct TreeNode
{
    struct TreeNode* left;
    struct TreeNode* right;
    char  elem;
};


TreeNode* BinaryTreeFromOrderings(char* inorder, char* aftorder, int length)
{
    if(length == 0)
    {
        return NULL;
    }
    TreeNode* node = new TreeNode;//Noice that [new] should be written out.
    node->elem = *(aftorder+length-1);
    std::cout<<node->elem<<std::endl;
    int rootIndex = 0;
    for(;rootIndex < length; rootIndex++)//a variation of the loop
    {
        if(inorder[rootIndex] ==  *(aftorder+length-1))
            break;
    }
    node->left = BinaryTreeFromOrderings(inorder, aftorder , rootIndex);
    node->right = BinaryTreeFromOrderings(inorder + rootIndex + 1, aftorder + rootIndex , length - (rootIndex + 1));
    
    return node;
}

int main(int argc, char** argv)
{
    char* af="AEFDHZMG";    
    char* in="ADEFGHMZ"; 
    BinaryTreeFromOrderings(in, af, 8); 
    printf("\n");
    return 0;
}

输出结果：GDAFEMHZ

应用：

        树是数据库中数据组织的一种重要形式。

        操作系统子父进程的关系本身就是一棵树。

        面向对象语言中类的继承关系。

        赫夫曼树