树和二叉树学习总结（三）

最新推荐文章于 2020-10-18 17:12:25 发布

二硫碘化钾kk

最新推荐文章于 2020-10-18 17:12:25 发布

阅读量441

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/a765528534/article/details/103105980

版权

数据结构专栏收录该内容

11 篇文章 1 订阅

订阅专栏

树、森林与二叉树的转换

一、树转化为二叉树

1.兄弟加线.

2.保留双亲与第一孩子连线,删去与其他孩子的连线.

3.顺时针转动,使之层次分明.

二、森林转换为二叉树

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

⑵ 从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。

三、二叉树转换为树或森林

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

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

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

四、森林的遍历

森林有两种遍历方法：

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

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

最优二叉树-哈夫曼树及哈夫曼编码

一、哈夫曼树

一、相关概念

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

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

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

三、哈夫曼树的特点：

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

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

四、哈夫曼树算法思想

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

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

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

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

五、哈夫曼树储存结构

设置一个数组huffTree[2n-1]保存哈夫曼树中各点的信息，数组元素的结点结构。

weight

lchild

rchild

parent

weight：权值域，保存该结点的权值； lchild：指针域，结点的左孩子结点在数组中的下标； rchild：指针域，结点的右孩子结点在数组中的下标； parent：指针域，该结点的双亲结点在数组中的下标。

struct element
{     int weight;
      int lchild, rchild, parent;
};
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<n; i++) 
       huffTree [i].weight=w[i];
    for (k=n; k<2*n-1; k++) {
        Select(huffTree, &i1, &i2); 
        huffTree[k].weight=huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent=k;     
        huffTree[i2].parent=k; 
        huffTree[k].lchild=i1;    
        huffTree[k].rchild=i2;
    }
}

六、哈夫曼编码

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

哈夫曼编码的基本思想：

以字符出现的频率最为权值构建一个哈夫曼树，然后利用哈夫曼树对字符进行编码。构造一棵哈夫曼树，是将所要编码的字符作为叶子结点，该字符在文件中的使用频率作为叶子结点的权值，权值越大的叶子离根越近。
哈夫曼算法采用的贪心算法的策略：每次从树的集合中取出没有双亲结点且权值最小的两棵树作为左右子树，构造一棵新树，新树根结点的权值是左右孩子结点权值之和，将新树插入到树的集合中。

线索二叉树

一、基本概念

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

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

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

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

二、存储结构

ltag

lchild

data

rchild

rtag

enum flag {Child, Thread}; 
template  <class T>
struct ThrNode
{
     T data;
     ThrNode<T>  *lchild, *rchild;
     flag ltag, rtag;
};

三、中序搜索二叉树

template <class T>
class InThrBiTree{    
   public:
        InThrBiTree();     
         ~ InThrBiTree( );    
        ThrNode *Next(ThrNode<T> *p); 
        void InOrder(ThrNode<T> *root); 
   private:
        ThrNode<T> *root;  
        ThrNode<T> *  Creat(); 
        void ThrBiTree(ThrNode<T> *root);
};
//构造函数
template <class T>ThrNode<T>* InThrBiTree<T>::Creat( ){
    ThrNode<T> *root;
    T ch;
    cout<<"请输入创建一棵二叉树的结点数据"<<endl;
    cin>>ch;
    if (ch=="#") root = NULL;
    else{	
         root=new ThrNode<T>;    
         root->data = ch;
         root->ltag = Child; root->rtag = Child;
         root->lchild = Creat( );
         root->rchild = Creat( ); 
    } 
	return root;
}
//中序线索化
template <class T>  void ThrBiTree<T>::ThrBiTree (ThrNode<T>*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<T>* pre = NULL

template <class T>
InThrBiTree<T>::InThrBiTree( )
{ 
	//ThrNode<T>* pre = NULL;
	this->root = Creat( );    
	ThrBiTree(root);
}
//在中序线索树中查找结点的中序遍历的后继
template <class T> ThrNode<T>* InThrBiTree<T>::Next(ThrNode<T>* p)
{
    ThrNode<T>* q;  //要查找的p的后继
    if (p->rtag==Thread)   q = p->rchild;
    else{   
        q = p->rchild; 
        while (q->ltag==Child)	{
            q = q->lchild;
        }
    }
    return q;
}
//中序遍历中序线索树
template <class T> 
void InThrBiTree<T>::InOrder(ThrNode<T> *root){
    ThrNode<T>* p = root;
    if (root==NULL)  return; 
    while (p->ltag==Child)   {       p = p->lchild;    }
    cout<<p->data<<" ";
    while (p->rchild!=NULL) {
        p = Next(p);
        cout<<p->data<<" ";
    }
    cout<<endl;
}