数据结构笔记：第五章 树和二叉树

树定义：

       在树中将数据元素称为节点。

       树：n（n≥0）个结点的有限集合。

树的基本术语：

       结点的度：结点所拥有的子树的个数。

       树的度：树中各结点度的最大值。

       叶子结点：度为0的结点，也称为终端结点。

       分支结点：度不为0的结点，也称为非终端结点。

       孩子结点：树中某结点子树的根结点称为这个结点的孩子结点，

       双亲结点：这个结点称为它孩子结点的双亲结点；  

       兄弟结点：具有同一个双亲的孩子结点互称为兄弟。 

       路径：如果树的结点序列n1, n2, …, nk有如下关系：结点ni是ni+1的双亲（1<=i

       路径长度：路径上经过的边的个数称为路径长度。 

       祖先、子孙：在树中，如果有一条路径从结点x到结点y，那么x就称为y的祖先，而y称为x的子孙。

       结点所在层数：根结点的层数为1；对其余任何结点，若某结点在第k层，则其孩子结点在第k+1层。

       树的深度：树中所有结点的最大层数，也称高度。

       树的宽度：树中每层节点个数最大值为树的宽度

       有序树、无序树：如果一棵树中结点的各子树从左到右是有次序的，称这棵树为有序树；反之，称为无序树。

      森林：m (m≥0)棵互不相交的树的集合。

树的遍历操作：

       树的遍历：从根结点出发，按照某种次序访问树中所有结点，使得每个结点被访问一次且仅被访问一次。

       树通常有前序遍历、后序遍历和层次遍历三种方式。

前序遍历 ：

       树的前序遍历操作定义为： 若树为空，不进行遍历；否则

                                                    ⑴ 访问根结点； 

                                                     ⑵ 按照从左到右的顺序前序遍历根结点的每一棵子树。

后序遍历：

        树的后序遍历操作定义为： 若树为空，则遍历结束；否则

                                                      ⑴ 按照从左到右的顺序后序遍历根结点的每一棵子树；

                                                      ⑵ 访问根结点。

层次遍历：

       树的层序遍历操作定义为： 从树的第一层（即根结点）开始，自上而下逐层遍历，

                                                   在同一层中，按从左到右的顺序对结点逐个访问。

树的存储结构：

        双亲表示法：

                             基本思想： 用一维数组来存储树的各个结点（一般按层序存储）， 数组中的一个元素对应树中的一个结点，                                                   每个结点记录两类信息：结点的数据信息以及该结点的双亲在数组中的下标。 

                                        data | parent

                                    data：存储树中结点的数据信息        parent：存储该结点的双亲在数组中的下标

        孩子表示法：

                           1、  链表中的每个结点包括一个数据域和多个指针域，每个指针域指向该结点的一个孩子结点。

                                data：数据域，存放该结点的数据信息；             child1~childd：指针域，指向该结点的孩子。

                           2、指针域的个数等于该结点的度

                                                     data | degree | child1 | 。。。| childd

                                 data：数据域，存放该结点的数据信息；             degree：度域，存放该结点的度；            

                                         child1~childd：指针域，指向该结点的孩子。 

       孩子兄弟表示法  ：

                                     firstchild | data | rightsib

                                    data：数据域，存储该结点的数据信息；

                                      firstchild：指针域，指向该结点第一个孩子；

                                      rightsib：指针域，指向该结点的右兄弟结点。

二叉树的定义：

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

     特点：

          ⑴ 每个结点最多有两棵子树； ⑵ 二叉树是有序的，其次序不能任意颠倒。

特殊的二叉树

      斜树

                  1 .所有结点都只有左子树的二叉树称为左斜树；

                   2 .所有结点都只有右子树的二叉树称为右斜树； 3.左斜树和右斜树统称为斜树。  

       斜树特点：

                    1. 在斜树中，每一层只有一个结点；

                     2.斜树的结点个数与其深度相同。 

    满二叉树：

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

        满二叉树特点：

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

                  2、只有度为0和度为2的结点。

   完全二叉树：

                 对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中编号为i的结点在二叉                树中的位置完全相同。

           在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树。

       完全二叉树特点：

                        1. 叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；

                         2. 完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。  

                         3. 深度为k的完全二叉树在k-1层上一定是满二叉树。

     完全二叉树性质：

                     1、 具有n个结点的完全二叉树的深度为 log2（n）  +1

                     2、对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为i（1≤i≤n）的结点（简称为结点                                      i），有：

                                       （1）如果i＞1，     则结点i的双亲结点的序号为  i/2；如果i＝1，     则结点i是根结点，无双亲结点。

                                         (2)如果2i≤n，     则结点i的左孩子的序号为2i；     如果2i＞n，则结点i无左孩子。

                                         (3)如果2i＋1≤n，     则结点i的右孩子的序号为2i＋1；如果2i＋1＞n，则结点 i无右孩子。   

二叉树基本性质：

    1、 二叉树的第i层上最多有2i-1个结点（i≥1）。

    2、一棵深度为k的二叉树中，最多有2k-1个结点，最少有k个结点。

    3、在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。

二叉树的遍历：

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

二叉树遍历方式：

    前序：若二叉树为空，则空操作返回；否则： ①访问根结点； ②前序遍历根结点的左子树； ③前序遍历根结点的右子树。

    中序：若二叉树为空，则空操作返回；否则： ①中序遍历根结点的左子树； ②访问根结点； ③中序遍历根结点的右子树。

    后续：若二叉树为空，则空操作返回；否则： ①后序遍历根结点的左子树； ②后序遍历根结点的右子树。 ③访问根结点；

    层次：二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对                结点逐个访问。

顺序存储结构：

          二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系             父子关系。

二叉链表：

   基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩                      子的指针。

                      lchild | data | rchild 

                data：数据域，存放该结点的数据信息；          

                 lchild：左指针域，存放指向左孩子的指针；          

                 rchild：右指针域，存放指向右孩子的指针。

二叉树的建立：  （递归）

     1、按前序扩展遍历序列输入输入节点的值

     2、如果输入节点之为“#”,则建立一棵空的子树

     3、否则，根结点申请空间，将输入值写入数据域中，

     4、以相同方法的创建根节点的左子树

     5、以相同的方法创建根节点的右子树 递归方法

template 
BiTree ::BiTree(){ 
      root=creat()；
}

template 
BiNode * BiTree ::Creat(){
     BiNode *root; char ch;
    cin>>ch;
    if (ch=='# ')     root=NULL; 
    else {
        root=new BiNode; 
        root->data=ch;
        root->lchild=creat(); 
        root->rchild= creat(); 
    }  
  return root
}

二叉树的遍历：

              前序遍历

              中序遍历

              后序遍历

              层次遍历

 

前序遍历：

              递归方法：

         

template   
void   BiTree::PreOrder(BiNode *root) 
{
        if (root ==NULL)  return;     
        else {
            cout<data;         
            PreOrder(           );    
            PreOrder(           );    
        }
 }

         非递归方法：

     1.栈s初始化（空栈）；

     2.循环直到root为空且栈s为空

                   2.1 当root不空时循环

                                   2.1.1 输出root->data;    

                                   2.1.2 将指针root的值保存到栈中；    

                                   2.1.3 继续遍历root的左子树（root=root->lchild）

                 2.2 如果栈s不空，则

                                    2.2.1 将栈顶元素弹出至root（root=s.pop()）；

                                    2.2.2 准备遍历root的右子树(root=root->rchild)；

template 
void BiTree::PreOrder(BiNode *root) {
  SeqStack *>  s;
     while (root!=NULL | | !s.empty()) {
         while (root!= NULL)  {
             cout<data;
             s.push（root）;
             root=root->lchild;  
         }
         if (!s.empty()) { 
             root=s.pop();
             root=root->rchild;  
         }
     }
}

中序遍历：

    递归：与前序遍历类似

    非递归方法：

         1.栈s初始化（空栈）；

          2.循环直到root为空且栈s为空

                  2.1 当root不空时循环        

                               2.1.1 将指针root的值保存到栈中；    

                               2.1.2 继续遍历root的左子树（root=root->lchild）

                 2.2 如果栈s不空，则

                              2.2.1 将栈顶元素弹出至root（root=s.pop()）；    

                              2.2.2 输出root->data;

                              2.2.3 准备遍历root的右子树(root=root->rchild)；

template 
void BiTree::InOrderwithoutD (BiNode *root)
	 {
     	stack< BiNode * > aStack;
         while(!aStack.empty()||root) {
             while(root){
                aStack.push(root);
                root=root->lchild; 
}
         if(!aStack.empty()){
		      root=aStack.top();				
		      aStack.pop(); 
                 cout<data;
                 root=root->rchild; 
	   }
  }
} 
	

后序遍历：

    非递归方法：

          1、 定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；

          2、无条件进行下面的工作  

              2-1 如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③

              2-2 p=p->lchild,重复①

              2-3 栈顶元素出栈P

              2-4 查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤

                          a、访问当前节点P

                          b、如果栈空 ，算法结束；

                          c、否则，栈顶元素出栈，转④

              2-5 修改P的标志，让P重新入栈，p=P->rchild,执行2 

栈中的元素类型定义StackElement
 	enum Tags{Left,Right};	//特征标识定义
	template 
	class StackElement		//栈元素的定义
	{
	public:
	BiTreeNode* pointer;     //指向二叉树结点的指针
	Tags tag; //特征标识申明
	};
#include 
Using namespace std;
template
void BiTree::PostOrderWithoutRecusion(BiTreeNode* root){
	StackElement element;
	stack > aStack;//栈申明
	BiTreeNode* pointer;
	if(root==NULL)
		return;//空树即返回
	else    pointer=root;				
	while(true){
	  while(pointer!=NULL){//进入左子树
		element.pointer=pointer;
		element.tag=Left; //沿左子树方向向下周游
		aStack.push(element);
		pointer=pointer->lchild; 	
		}
   		element=aStack.pop();
            pointer=element.pointer;
while(element.tag==Right){
        cout<data;
        if(aStack.empty())  return;
	    else{
	       element=aStack.pop();
		     pointer=element.pointer;
	  	 }//end else
        } //endwhile
       element.tag=Right; 
    aStack.push(element);
    pointer=pointer->rchild(); 
     }//end while
}

层次遍历：

1、队列Q初始化；

2. 如果二叉树非空，将根指针入队；

3.  循环直到队列Q为空      

       3.1 q=队列Q的队头元素出队；      

       3.2 访问结点q的数据域；      

       3.3 若结点q存在左孩子，则将左孩子指针入队；      

       3.4 若结点q存在右孩子，则将右孩子指针入队；

#include 
using namespace std;
template
void BiTree::LevelOrder(BinaryTreeNode* root){
	queue*> aQueue;
	if(root)
		aQueue.push(root);
	while(!aQueue.empty())
	{
		root=aQueue.front(); //取队列首结点
	 	aQueue.pop();
                     cout<data;//访问当前结点
		if(root->lchild)	//左子树进队列
			aQueue.push(root->lchild);
		if(root->rchild) //右子树进队列
			aQueue.push(root->rchild); 	
	}//end while
}

三叉链表：

          在二叉链表的基础上增加了一个指向双亲的指针域。

     节点结构：

           lchild | data | parent | rchild

                        parent域为指向该结点的双亲结点的指针。

         结点数据类型声明：

                              template struct Node {     

                                                T data;     

                                              Node * lchild, *rchild,*parent; };  

  建立三叉链表（递归）

       按前序扩展遍历序列输入输入节点的值

       如果输入节点之为“#”,则建立一棵空的子树

       否则，根结点申请空间，将输入值写入数据域中，同时将三个指针赋空值

       以相同方法的创建根节点的左子树，并设置子树的根的parent

       以相同的方法创建根节点的右子树，并设置子树的根的parent

template 
BiNode * BiTree::Creat(BiNode * &root ,BiNode *parent){
	T ch;
	cout<<"请输入创建一棵二叉树的结点数据"<>ch;
    if (ch=="#") root = NULL;
    else{ 
	     root = new BiNode;       //生成一个结点
          root->data=ch;
	     root->parent=parent;
         Creat(root->lchild,root );    //递归建立左子树
         Creat(root->rchild,root);    //递归建立右子树
    } 
    return root;
}

森林转化为二叉树：

          ⑴ 将森林中的每棵树转换成二叉树；

           ⑵ 从第二棵二叉树开始，     

                          依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，   

                          当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。

二叉树转化为森林：

          ⑴ 加线——若某结点x是其双亲y的左孩子，则把结点x的右孩子、右孩子的右孩子、……，都与结点y用线连起来；

          ⑵ 去线——删去原二叉树中所有的双亲结点与右孩子结点的连线；

           ⑶ 层次调整——整理由⑴、⑵两步所得到的树或森林，使之层次分明。

森林的遍历：

     森林有两种遍历方法：

                  前序遍历：前序遍历森林中的每一棵树。

                  后序遍历：后序遍历森林中的每一棵树。

哈夫曼树：

           给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。

     哈夫曼树的特点：

                       1. 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。

                       2. 只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点.

      存储结构：

                     weight | lchild | rchild | parent

             weight：权值域，保存该结点的权值；            

             lchild：指针域，结点的左孩子结点在数组中的下标；            

             rchild：指针域，结点的右孩子结点在数组中的下标；            

             parent：指针域，该结点的双亲结点在数组中的下标。

   思想：

        1、数组huffTree初始化，所有元素结点的双亲、左     右孩子都置为-1；

        2. 数组huffTree的前n个元素的权值置给定值w[n]；

        3. 进行n-1次合并    

               3.1 在二叉树集合中选取两个权值最小的根结点，           其下标分别为i1, i2；    

               3.2 将二叉树i1、i2合并为一棵新的二叉树k(初值为n；依次递增)；

void HuffmanTree(element huffTree[ ], int w[ ], int n ) {
    for (i=0; i<2*n-1; i++) {
       huffTree [i].parent= -1;
       huffTree [i].lchild= -1;
       huffTree [i].rchild= -1;   
    }
    for (i=0; i

线索： 将二叉链表中的空指针域指向前驱结点和后继结点的指针被称为线索；

  线索链表结构：

                ltag | lchild | data | child | rtag

        ltag：0:  lchild指向该结点的左孩子

                 1: lchild指向该结点的前驱结点

        rtag：

                0: rchild指向该结点的右孩子

               1: rchild指向该结点的后继结点

二叉树的遍历方式有4种，故有4种意义下的前驱和后继，相应的有4种线索二叉树：

                            ⑴ 前序线索二叉树 ⑵ 中序线索二叉树 ⑶ 后序线索二叉树 ⑷ 层序线索二叉树

中序线索化二叉树：递归实现

    基本思想： 在遍历的过程中完成线索化

                      可以采用前序、中序、后序遍历建立前序线索二叉树、中序线索二叉树和后序线索二叉树。

                      中序线索二叉树的构造方法 中序线索化根结点的左子树；

                                                                   对根结点进行线索化；

                                                                   中序线索化根结点的右子树；

template   void ThrBiTree::ThrBiTree (ThrNode*root) {
      if (root==NULL) return;         //递归结束条件
   
      ThrBiTree(root->lchild); 	
if (!root->lchild){             //对root的左指针进行处理
        root->ltag = Thread;   
        root->lchild = pre;        //设置pre的前驱线索
   }
 if (!root->rchild) root->rtag = Thread; 

  if(pre != NULL){
       if (pre->rtag==Thread)  pre->rchild = root; 
  }
   pre = root;
   ThrBiTree(root->rchild);
}
ThrNode* pre = NULL

template 
InThrBiTree::InThrBiTree( )
{ 
	//ThrNode* pre = NULL;
	this->root = Creat( );    
	ThrBiTree(root);
}