二叉树、森林、哈夫曼树

二叉树的定义

二叉树是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层上一定是满二叉树。

二叉树的基本性质

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

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

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

完全二叉树的基本性质

具有n个结点的完全二叉树的深度为 log2n  +1。

对一棵具有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无右孩子。

二叉树的逻辑结构：

对一棵具有n个结点的完全二叉树中从1开始按层序编号，则

结点i的双亲结点为  i/2；

结点i的左孩子为2i；

结点i的右孩子为2i＋1。

二叉树的遍历操作

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

考虑二叉树的组成：

二叉树

根结点D

左子树L

右子树R

如果限定先左后右，则二叉树遍历方式有三种：

前序：DLR

中序：LDR

后序：LRD

层序遍历：按二叉树的层序编号的次序访问各结点。

前序（根）遍历

若二叉树为空，则空操作返回；否则：

①访问根结点；

②前序遍历根结点的左子树；

③前序遍历根结点的右子树。

中序（根）遍历

若二叉树为空，则空操作返回；否则：

①中序遍历根结点的左子树；

②访问根结点；

③中序遍历根结点的右子树。

后序（根）遍历

若二叉树为空，则空操作返回；否则：

①后序遍历根结点的左子树；

②后序遍历根结点的右子树。

③访问根结点；

层序遍历

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

二叉树的存储结构及实现

顺序存储结构

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

二叉链表

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

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

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

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

template <class T>

struct BiNode

{

    T data;

    BiNode<T> *lchild, *rchild;

};

二叉链表存储结构的类声明

template <class T>

class BiTree

{   

  public:

       BiTree();

        ~BiTree( );           

        void PreOrder(){PreOrder(root);}

        void InOrder() {InOrder(root);}

        void PostOrder() {PostOrder(root);}

        void LevelOrder(){LeverOrder(root)};

  private:

        BiNode<T> *root;

        BiNode<T> * Creat( );

        void Release(BiNode<T> *root);

        void PreOrder(BiNode<T> *root);

        void InOrder(BiNode<T> *root);

        void PostOrder(BiNode<T> *root);

        void LevelOrder(BiNode<T> *root);

 };

前序遍历——递归算法

template   <class T>

void   BiTree::PreOrder(BiNode<T> *root)

{

        if (root ==NULL)  return;    

        else {

            cout<<root->data;         

            PreOrder(           );   

            PreOrder(           );   

        }

 }

template   <class T>

void   BiTree::PreOrder(BiNode<T> *root) {

        if (root ==NULL)  return;    

        else {

           cout<<root->data;        

           PreOrder(root->lchild);   

            PreOrder(root->rchild);   

        }

 }

前序遍历——非递归算法

二叉树前序遍历的非递归算法的关键：

在前序遍历过某结点的整个左子树后，如何找到该结点的右子树的根指针。

解决办法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。

栈是实现递归的最常用的结构

思想：

遇到一个结点，就访问该结点，并把此结点推入栈中，然后遍历它的左子树；

遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。

前序遍历——非递归算法（伪代码）

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 <class T>

void BiTree::PreOrder(BiNode<T> *root) {

  SeqStack<BiNode<T> *>  s;

     while (root!=NULL | | !s.empty()) {

         while (root!= NULL)  {

             cout<<root->data;

             s.push（root）;

             root=root->lchild; 

         }

         if (!s.empty()) {

             root=s.pop();

             root=root->rchild; 

         }

     }

}

二叉树的建立

遍历是二叉树各种操作的基础，可以利用遍历的思想完成二叉树的各种操作，例如建立一棵二叉树。

设二叉树中的结点均为一个字符。假设扩展二叉树的前序遍历序列由键盘输入，root为指向根结点的指针，二叉链表的建立过程是：

1. 按扩展前序遍历序列输入结点的值
2. 如果输入结点值为“#”,则建立一棵空的子树
3. 否则，根结点申请空间，将输入值写入数据域中，
4. 以相同方法的创建根结点的左子树
5. 以相同的方法创建根结点的右子树

递归方法

template <class T>

class BiTree{

public:

       BiTree();

        ~BiTree( );           

        void PreOrder(){PreOrder(root);}

        void InOrder() {InOrder(root);}

        void PostOrder() {PostOrder(root);}

        void LevelOrder();

  private:

        BiNode<T> *root;

        void Creat(BiNode<T> *& root);

        void Release(BiNode<T> *root);

        void PreOrder(BiNode<T> *root);

        void InOrder(BiNode<T> *root);

        void PostOrder(BiNode<T> *root);

        void LevelOrder(BiNode<T> *root);

};

template <class T>

void BiTree<T>::Creat(BiNode<T> * &root  )

{

      T ch;

      cout<<"请输入创建一棵二叉树的结点数据"<<endl;

      cin>>ch;

         if (ch=="#") root = NULL;

         else{

             root = new BiNode<T>;       //生成一个结点

                root->data=ch;

               Creat(root->lchild );    //递归建立左子树

               Creat(root->rchild);    //递归建立右子树

    }

}

中序遍历——递归算法

template <class T>

void BiTree::InOrder (BiNode<T> *root)

{

         if (root==NULL) return;    

         else {

               InOrder(root->lchild);

               cout<<root->data;

               InOrder(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 <class T>

void BiTree::InOrderwithoutD (BiNode<T> *root)

   {

        stack< BiNode<T> * > aStack;

              while(root){

  aStack.push(root);

  root=root->lchild;    

    }

       if(!aStack.empty()){

          root=aStack.top();          

          aStack.pop();

                 cout<<root->data;

                 root=root->rchild;

     }

  }

}

后序遍历——递归算法

template <class T>

void BiTree::PostOrder(BiNode<T> *root)

{

    if (root==NULL) return;

    else {

         PostOrder(root->lchild);

         PostOrder(root->rchild);

         cout<<root->data;         

    }

}

非递归后序遍历二叉树

思想:

遇到一个结点，把它推入栈中，遍历它的左子树

左子树遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树

遍历遍右子树后才能从栈顶托出该结点并访问之

算法分析

1. 1. 定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；
   2. 无条件进行下面的工作
      • 如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③
      • p=p->lchild,重复①
      • 栈顶元素出栈P
      • 查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤
        1. 访问当前节点P
        2. 如果栈空 ，算法结束；
        3. 否则，栈顶元素出栈，转④
      • 修改P的标志，让P重新入栈，p=P->rchild,执行2
2. 栈中的元素类型定义StackElement
3.    enum Tags{Left,Right};  //特征标识定义
4.    template <class T>
5.    class StackElement      //栈元素的定义
6.    {
7.    public:
8.    BiTreeNode<T>* pointer;     //指向二叉树结点的指针
9.    Tags tag; //特征标识申明
10.    };

二叉树的非递归遍历总结

都是沿着左分支访问，直到左分支为空时，再依次对栈中节点的右分支进行处理。（遵循从左至右的遍历原则，体现深度优先搜索的思想）

前序遍历：每个节点只进栈一次，在进栈前访问节点

中序遍历：每个节点进栈一次，在出栈时访问节点

后序遍历：每个节点进栈两次，在第二次出栈时访问节点

需要用栈实现

根据后续遍历的要求及栈操作的特点（FILO），依次将

根结点

根结点的右儿子

根节点的左儿子

入栈（不访问）

当结点出栈时再进行访问

当栈顶出现叶子结点时，直接进行出栈操作

当刚出栈元素和栈顶元素之间关系是“儿子-双亲”关系时，进行出栈操作

层序遍历

1. 队列Q初始化；

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

1. 循环直到队列Q为空

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

      3.2 访问结点q的数据域；

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

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

#include <queue>

using namespace std;

template<class T>

void BiTree<T>::LevelOrder(BinaryTreeNode<T>* root){

  queue<BiTreeNode<T>*> aQueue;

  if(root)

    aQueue.push(root);

  while(!aQueue.empty())

  {

    root=aQueue.front(); //取队列首结点

     aQueue.pop();

                     cout<<pointer->data;//访问当前结点

    if(root->lchild)  //左子树进队列

       aQueue.push(root->lchild);

    if(root->rchild) //右子树进队列

       aQueue.push(root->rchild);   

  }//end while

}

二叉树的析构

template<class T>

void BiTree<T>::Release(BiNode<T>* root){

  if (root != NULL){                 

      Release(root->lchild);   //释放左子树

      Release(root->rchild);   //释放右子树

      delete root;

  } 

}

template<class T>

BiTree<T>::~BiTree(void)

{

  Release(root);

}

统计叶子节点的数目

增加一个数据成员，leafcount, 初值为0

对树进行遍历。 如果一个节点是叶子，则将leafcount+1；

可以在前序、中序或后序的遍历过程中进行计算。

算法分析

从根节点出发

判断当前节点是否是叶子节点，如果是，则叶子数+1

否则，在左子树中遍历，并统计叶子节点的数目，在右子树中进行遍历，并统计叶子节点的数目

计算树的高度

高度的定义

max（左子树高度，右子树高度）+1

算法分析

从根节点出发开始计算，

如果root==NULL, 高度为0；

否则，分别计算左子树的高度；右子树的高度；返回max（左子树高度，右子树高度）+1

递归的定义

判断一棵树是否是完全二叉树

基于层次遍历。

在层次遍历中，如果遇到一个节点

只有右儿子，没有左儿子，

false;

只有左，没有右

If (is_leaf==true) return false;

Else is_leaf=true;

两个儿子均为空

is_leaf=true

两个儿子均不空

If (is_leaf==true) return false;

将存在的儿子入队

能遍历完所有节点，即为完全二叉树

树和二叉树之间的对应关系

        树：兄弟关系

二叉树：双亲和右孩子

        树：双亲和长子

二叉树：双亲和左孩子

树的前序遍历等价于二叉树的前序遍历！

树的后序遍历等价于二叉树的中序遍历！

森林转换为二叉树

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

⑵ 从第二棵二叉树开始，

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

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

森林的遍历

森林有两种遍历方法：

⑴前序（根）遍历：前序遍历森林即为前序遍历森林中的每一棵树。

⑵后序（根）遍历：后序遍历森林即为后序遍历森林中的每一棵树。  

叶子结点的权值：对叶子结点赋予的一个有意义的数值量。

二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为：

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

哈夫曼树的特点：

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

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

哈夫曼算法基本思想：

⑴ 初始化：由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}；

⑵ 选取与合并：在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和；

⑶ 删除与加入：在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中；

 ⑷ 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树。

哈夫曼算法的存储结构

其中：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；依次递增)；

哈夫曼树应用——哈夫曼编码

编码：给每一个对象标记一个二进制位串来表示一组对象。

例：ASCII，指令系统

等长编码：表示一组对象的二进制位串的长度相等。

不等长编码：表示一组对象的二进制位串的长度不相等。

前缀编码：一组编码中任一编码都不是其它任何一个编码的前缀 。

前缀编码保证了在解码时不会有多种可能。

哈夫曼编码算法的实现

从叶子结点到根， 逆向求每个叶子结点对应的哈夫曼编码

根据huffman树中叶子节点的个数，构造一个字符串数组，每个数组分量是一个字符串，用于存放该节点对应的huffman编码

对每个叶子节点i(i=0; i<n; i++)，进行下面的工作：

线索二叉树

二叉树的遍历运算是将二叉树中结点按一定规律线性化的过程。

当以二叉链表作为存储结构时，只能找到结点的左、右孩子信息，而不能直接得到结点在遍历序列中的前驱和后继信息。

要得到这些信息可采用以下两种方法：

第一种方法是将二叉树遍历一遍，在遍历过程中便可得到结点的前驱和后继，但这种动态访问浪费时间；

第二种方法是充分利用二叉链表中的空链域， 将遍历过程中结点的前驱、 后继信息保存下来。

线索链表

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

线索化：使二叉链表中结点的空链域存放其前驱或后继信息的过程称为线索化；

线索二叉树：加上线索的二叉树称为线索二叉树。

线索二叉树

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

⑴ 前序线索二叉树

⑵ 中序线索二叉树

⑶ 后序线索二叉树

⑷ 层序线索二叉树