zoukankan      html  css  js  c++  java

  • 二叉树的应用详解

    二叉树的应用详解 - 数据结构

     
     


    概述：

    平衡树——特点：所有结点左右子树深度差≤1

    排序树——特点：所有结点“左小右大
    字典树——由字符串构成的二叉排序树
    判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重）
    带权树——特点：路径带权值（例如长度）

    最优树——是带权路径长度最短的树，又称 Huffman树，用途之一是通信中的压缩编码。

    1. 二叉排序树（二叉查找树 Binary Search Tree）：

    1.1 二叉排序树：

    或是一棵空树；或者是具有如下性质的非空二叉树：

     （1）若左子树不为空，左子树的所有结点的值均小于根的值；

     （2）若右子树不为空，右子树的所有结点均大于根的值；

     （3）它的左右子树也分别为二叉排序树。

    例：二叉排序树 如图9.7：

                     



          二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索,插入,删除的复杂度等于树高，期望O(logn),最坏O(n)(数列有序,树退化成线性表).
    虽然二叉排序树的最坏效率是O(n),但它支持动态查询,且有很多改进版的二叉排序树可以使树高为O(logn),如SBT,AVL,红黑树等.故不失为一种好的动态排序方法.

    2.2 二叉排序树b中查找

    在二叉排序树b中查找x的过程为：

    1. 若b是空树，则搜索失败，否则：
    2. 若x等于b的根节点的数据域之值，则查找成功；否则：
    3. 若x小于b的根节点的数据域之值，则搜索左子树；否则：
    4. 查找右子树。
    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. Status SearchBST(BiTree T, KeyType key, BiTree f, BiTree &p){    
    2.     //在根指针T所指二叉排序樹中递归地查找其关键字等于key的数据元素，若查找成功，    
    3.     //则指针p指向该数据元素节点，并返回TRUE，否则指针P指向查找路径上访问的    
    4.     //最好一个节点并返回FALSE，指针f指向T的双亲，其初始调用值为NULL    
    5.     if(!T){ p=f; return FALSE;} //查找不成功    
    6.     else if EQ(key, T->data.key) {P=T; return TRUE;} //查找成功    
    7.     else if LT(key,T->data.key)     
    8.         return SearchBST(T->lchild, key, T, p); //在左子树继续查找    
    9.     else return SearchBST(T->rchild, key, T, p); //在右子树继续查找    
    10. }    

    2.3 在二叉排序树插入结点的算法

    向一个二叉排序树b中插入一个结点s的算法，过程为：

    1. 若b是空树，则将s所指结点作为根结点插入，否则：
    2. 若s->data等于b的根结点的数据域之值，则返回，否则：
    3. 若s->data小于b的根结点的数据域之值，则把s所指结点插入到左子树中，否则：
    4. 把s所指结点插入到右子树中。
    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. /*当二叉排序树T中不存在关键字等于e.key的数据元素时，插入e并返回TRUE，否则返回FALSE*/    
    2. Status InsertBST(BiTree &T, ElemType e){    
    3.     if(!SearchBST(T, e.key, NULL,p){    
    4.         s=(BiTree)malloc(sizeof(BiTNode));    
    5.         s->data = e; s->lchild = s->rchild = NULL;    
    6.         if(!p)  T-s;    //被插结点*s为新的根结点    
    7.         else if LT(e.key, p->data.key) p->lchld = s;  //被子插结点*s为左孩子    
    8.         else p->rchild = s;  //被插结点*s为右孩子    
    9.         return TRUE;    
    10.     }    
    11.     else return FALSE;  //树中已有关键字相同的结点，不再插入    
    12. }    

    2.4 在二叉排序树删除结点的算法

    在二叉排序树删去一个结点，分三种情况讨论：

    1. 若*p结点为叶子结点，即PL(左子树)和PR(右子树)均为空树。由于删去叶子结点不破坏整棵树的结构，则只需修改其双亲结点的指针即可。
    2. 若*p结点只有左子树PL或右子树PR，此时只要令PL或PR直接成为其双亲结点*f的左子树即可，作此修改也不破坏二叉排序树的特性。
    3. 若*p结点的左子树和右子树均不空。在删去*p之后，为保持其它元素之间的相对位置不变，可按中序遍历保持有序进行调整，可以有两种做法：其一是令*p的左子树为*f的左子树，*s为*f左子树的最右下的结点，而*p的右子树为*s的右子树；其二是令*p的直接前驱（或直接后继）替代*p，然后再从二叉排序树中删去它的直接前驱（或直接后继）。在二叉排序树上删除一个结点的算法如下：
    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. Status DeleteBST(BiTree &T, KeyType key){    
    2.     //若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素，并返回    
    3.     //TRUE；否则返回FALSE     
    4.     if(!T) return FALSE;    //不存在关键字等于key的数据元素    
    5.     else{    
    6.         if(EQ(key, T->data.key)) {return Delete(T)};     找到关键字等于key的数据元素    
    7.         else if(LT(key, T->data.key))    return DeleteBST(T->lchild, key);    
    8.         else return DeleteBST(T->rchild, key);    
    9.     }    
    10. }    
    11. Status Delete(BiTree &p){    
    12.     //从二叉排序树中删除结点p，并重接它的左或右子树     
    13.     if(!p->rchild){  //右子树空则只需重接它的左子树    
    14.         q=p; p=p->lchild;    free(q);    
    15.     }    
    16.     else if(!p->lchild){ //左子树空只需重接它的右子树    
    17.         q=p; p=p->rchild; free(q);    
    18.     }    
    19.     else{   //左右子树均不空    
    20.         q=p;     
    21.         s=p->lchild;    
    22.         while(s->rchild){     
    23.             q=s;     
    24.             s=s->rchild    
    25.         }   //转左，然后向右到尽头    
    26.         p->data = s->data;    //s指向被删结点的“前驱”    
    27.         if(q!=p)        
    28.             q->rchild = s->lchild; //重接*q的右子树    
    29.         else     
    30.             q->lchild = s->lchild;    //重接*q的左子树    
    31.         free(s);    
    32.     }    
    33.     return TRUE;    
    34. }    
    [cpp] view plain copy
     
     print?
    1. Status DeleteBST(BiTree &T, KeyType key){  
    2.     //若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素，并返回  
    3.     //TRUE；否则返回FALSE  
    4.     if(!T) return FALSE;    //不存在关键字等于key的数据元素  
    5.     else{  
    6.         if(EQ(key, T->data.key)) {return Delete(T)};     找到关键字等于key的数据元素  
    7.         else if(LT(key, T->data.key))    return DeleteBST(T->lchild, key);  
    8.         else return DeleteBST(T->rchild, key);  
    9.     }  
    10. }  
    11. Status Delete(BiTree &p){  
    12.     //从二叉排序树中删除结点p，并重接它的左或右子树  
    13.     if(!p->rchild){  //右子树空则只需重接它的左子树  
    14.         q=p; p=p->lchild;    free(q);  
    15.     }  
    16.     else if(!p->lchild){ //左子树空只需重接它的右子树  
    17.         q=p; p=p->rchild; free(q);  
    18.     }  
    19.     else{   //左右子树均不空  
    20.         q=p;   
    21.                 s=p->lchild;  
    22.         while(s->rchild){   
    23.                        q=s;   
    24.                        s=s->rchild  
    25.                 }   //转左，然后向右到尽头  
    26.         p->data = s->data;    //s指向被删结点的“前驱”  
    27.         if(q!=p)      
    28.                        q->rchild = s->lchild; //重接*q的右子树  
    29.         else   
    30.                         q->lchild = s->lchild;    //重接*q的左子树  
    31.         free(s);  
    32.     }  
    33.     return TRUE;  
    34. }  

    2. 5二叉排序树性能分析

    每个结点的Ci为该结点的层次数。最坏情况下，当先后插入的关键字有序时，构成的二叉排序树蜕变为单支树，树的深度为n，其平均查找长度为 （和顺序查找相同），最好的情况是二叉排序树的形态和折半查找的判定树相同，其平均查找长度和log2(n)成正比 （O(log2(n))）。


     
    2.6 二叉排序树的优化
        Size Balanced Tree(SBT)
        AVL树
        红黑树
        Treap(Tree+Heap)
    这些均可以使查找树的高度为O(logn)
     

    2. 平衡树二叉树）（又称AVL 树）：

    1. 1 平衡二叉树（Balanced Binary Tree）

    性质：  左右子树都是平衡二叉树且所有结点左、右子树深度之差的绝对值 ≤ 1。

    若定义结点的“平衡因子”  BF（Balance Factor） = 左子树深度 –右子树深度 则：平衡二叉树中所有结点的BF ∈[ -1, 0, 1 ]

    例：判断下列二叉树是否AVL树？


    常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O（log2n），大大降低了操作的时间复杂度。

    平衡二叉树是二叉排序树的另一种形式。

    我们希望由任何初始序列构成的二叉排序树都是平衡二叉树。因为平衡二叉树上任何结点的左右子树的深度之差都不超过1，则可以证明它的深度和logN是同数量级的（其中N是结点的个数）。由此，它的平均查找长度也和logN同数量级。

    C语言描述:

    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. typedef struct  BSTNode {    
    2.     ElemType    data;    
    3.     int     bf;     //结点的平衡因子    
    4.     struct BSTNode  *lchild, *rchild;       
    5.     //左、右孩子指针    
    6. } BSTNode, * BSTree;    
    [cpp] view plain copy
     
     print?
    1. typedef struct  BSTNode {  
    2.         ElemType    data;  
    3.         int     bf;     //结点的平衡因子  
    4.         struct BSTNode  *lchild, *rchild;     
    5.                         //左、右孩子指针  
    6.     } BSTNode, * BSTree;  

    构造二叉平衡（查找）树的方法是：在插入过程中，采用平衡旋转技术。

    插入算法 :

    算法思想：

    在平衡二叉排序树BBST上插入一个新的数据元素e的递归算法可描述如下：

    1．若BBST为空树，则插入一个数据元素为e的新结点作为BBST的根结      点，树的深度增1； 

    2．若e的关键字和BBST的根结点的关键字相等，则不进行插入； 

    3．若e的关键字小于BBST的根结点的关键字，而且在BBST的左子树中不存在和e有相同关键字的结点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加（＋1）时，分别就下列不同情况处理之：

        i．BBST的根结点的平衡因子为－1（右子树的深度大于左子树的深度）：则将根结点的平衡因子更改为0，BBST的深度不变；

        ii．BBST的根结点的平衡因子为0（左、右子树的深度相等）：则将根结点的平衡因子更改为1，BBST的深度增1； 

        iii．BBST的根结点的平衡因子为1（左子树的深度大于右子树的深度）：

             a. 若BBST的左子树根结点的平衡因子为1，则需进行单向右旋平衡处理，并且在右旋处理之后，将根结点和其右子树根结点的平衡因子更改为0，树的深度不变；

             b. 若BBST的左子树根结点的平衡因子为－1，则需进行先向左、后向右的双向旋转平衡处理，并且在旋转处理之后，修改根结点和其左、右子树根结点的平衡因子，树的                深度不变。

    4．若e的关键字大于BBST的根结点的关键字，而且在BBST的右子树中不存在和e有相同关键字的结点，则将e插入在BBST的右子树上，并且当插入之后的右子树深度增加（＋1）时，分别就不同情况处理之。其处理操作和上述3．中描述相对称。

    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. typedef struct  BSTNode {    
    2.     ElemType    data;    
    3.     int     bf;     //结点的平衡因子    
    4.     struct BSTNode  *lchild, *rchild;       
    5.     //左、右孩子指针    
    6. } BSTNode, * BSTree;    
    7. void R_Rotate (BSTree &p) {    
    8.     //对以*p为根的二叉排序树作右旋处理，处理之后p指向新的树根结点，     
    9.     //即旋转处理之前的左子树的根结点     
    10.     lc = p－>lchild;          //lc指向的*p的左子树根结点    
    11.     p－>lchild = lc－>rchild;       //lc的右子树挂接为*p的左子树    
    12.     lc－>rchild = p;      
    13.     p = lc;             //p指向新的根结点    
    14. } // R_Rotate     
    15.   
    16. void L_Rotate (BSTree &p) {    
    17.     //对以*p为根的二叉排序树作左旋处理，处理之后p指向新的树根结点，    
    18.     //即旋转处理之前的右子树的根结点     
    19.     rc = p－>rchild;          //rc指向的*p的右子树根结点    
    20.     p－>rchild = rc－>lchild;       //rc的左子树挂接为*p的右子树    
    21.     rc－>lchild = p;      
    22.     p = rc;             //p指向新的根结点     
    23. } // L_Rotate     
    24.   
    25.   
    26.   
    27. #define LH  +1      //左高     
    28. #define EH  0       //等高     
    29. #define RH  -1      //右高     
    30.   
    31.   
    32.   
    33. Status InsertAVL (BSTree &T, ElemType e, Boolean &taller) {    
    34.     //若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入     
    35.     //一个数据元素为e的新结点，并返回1，否则返回0。若因插入而使二    
    36.     //叉排序树失去平衡，则作平衡旋转处理，布尔变量taller反映T长高    
    37.     //与否。     
    38.     if (!T) {      //插入新结点，树“长高”，置taller为TRUE    
    39.         T = (BSTree) malloc (sizeof (BSTNode));    
    40.         T－>data = e;    
    41.         T－>lchild = T－>rchild = NULL;    
    42.         taller = TRUE;    
    43.     }    
    44.     else {    
    45.         if (EQ(e.key, T－>data.key))      //树中已存在和e有相同关键字的    
    46.         {taller = FALSE; return 0;}     //结点则不再插入    
    47.         if (LT(e.key, T－>data.key)) {        //应继续在*T的左子树中进行搜索    
    48.             if (!InsertAVL(T－>lchild, e, taller))    //未插入    
    49.                 return  0;    
    50.             if (taller)         //已插入到*T的左子树中且左子树“长高”    
    51.                 switch (T－>bf) {     //检查*T的平衡度    
    52.                     case LH:        //原本左子树比右子树高，需要作左平衡处理    
    53.                         LeftBalance (T);    
    54.                         taller = FALSE;    
    55.                         break;    
    56.                     case EH:            //原本左右子树等高，现因左子树增高而使树增高    
    57.                         T－>bf = LH;    
    58.                         taller = TRUE;    
    59.                         break;    
    60.   
    61.                     case RH:        //原本右子树比左子树高，现左、右子树等高    
    62.                         T－>bf = EH;    
    63.                         taller = FALSE;    
    64.                         break;    
    65.             } // switch (T－>bf)    
    66.         } // if     
    67.         else {      //应继续在*T的右子树中进行搜索    
    68.             if (!InsertAVL(T－>rchild, e, taller))        //未插入    
    69.                 return  0;    
    70.             if (taller)     //已插入到*T的右子树中且右子树“长高”    
    71.                 switch (T－>bf) { //检查*T的平衡度    
    72.                 case LH:        //原本右子树比左子树高，现左、右子树等高    
    73.                     T－>bf = EH;    
    74.                     taller = FALSE;    
    75.                     break;    
    76.                 case EH:    //原本左右子树等高，现因右子树增高而使树增高    
    77.                     T－>bf = RH;    
    78.                     taller = TRUE;    
    79.                     break;    
    80.                 case RH:        //原本右子树比左子树高，需要作右平衡处理       
    81.                     RightBalance (T);    
    82.                     taller = FALSE;    
    83.                     break;    
    84.             } // switch (T－>bf)     
    85.         } // else     
    86.     } // else     
    87.     return  1;     
    88. } // InsertAVL     
    89.   
    90.   
    91. void LeftBalance (BSTree &T) {    
    92.     //对以指针T所指结点为根的二叉树作左平衡旋转处理，本算法     
    93.     //结束时，指针T指向新的根结点     
    94.     lc = T－>lchild;          //lc指向*T的左子树根结点    
    95.     switch (lc－>bf) {        //检查*T的左子树的平衡度，并作相应平衡处理    
    96.             case LH:    //新结点插入在*T的左孩子的左子树上，要作单右旋处理    
    97.                 T－>bf = lc－>bf = EH;    
    98.                 R_Rotate (T);    
    99.                 break;    
    100.             case RH:    //新结点插入在*T的左孩子的右子树上，要作双旋处理    
    101.                 rd = lc－>rchild;     //rd指向*T的左孩子的右子树根    
    102.                 switch (rd－>bf) {    //修改*T及其左孩子的平衡因子    
    103.             case LH:    
    104.                 T－>bf = RH;    
    105.                 lc－>bf = EH;    
    106.                 break;    
    107.             case EH:    
    108.                 T－>bf = lc－>bf = EH;    
    109.                 break;    
    110.             case RH:    
    111.                 T－>bf = EH;    
    112.                 lc－>bf = LH;    
    113.                 break;    
    114.                 } // switch (rd－>bf)     
    115.                 rd－>bf = EH;    
    116.                 L_Rotate (T－>lchild);   //对*T的左子树作左旋平衡处理    
    117.                 R_Rotate (T);      //对*T作右旋平衡处理    
    118.     } // switch (lc－>bf)     
    119. } // LeftBalance    

    3. 判定树（决策树）：

          二分查找过程可用二叉树来描述：把当前查找区间的中间位置上的结点作为根，左子表和右子表中的结点分别作为根的左子树和右子树。由此得到的二叉树，称为描述二分查找的判定树(Decision Tree 决策树)或比较树(Comparison Tree)。

    注意：
        　判定树的形态只与表结点个数n相关，而与输入实例中R[1..n].keys的取值无关。
    【例】具有11个结点的有序表可用下图所示的判定树来表示。
     

    举例：12个球如何用天平只称3次便分出轻重？

    分析：12个球中必有一个非轻即重，即共有24种“次品”的可能性。每次天平称重的结果有3种，连称3次应该得到的结果有33=27种。说明仅用3次就能找出次品的可能性是存在的。

    思路：首先，将12个球分三组，每组4个，任意取两组称。会有两种情况：平衡，或不平衡。其次，一定要利用已经称过的那些结论；即充分利用“旧球”的标准性作为参考。

     
    二分查找判定树的查找
    二分查找就是将给定值K与二分查找判定树的根结点的关键字进行比较。若相等，成功。否则若小于根结点的关键字，到左子树中查找。若大于根结点的关键字，则到右子树中查找。
    　　【例】对于有11个结点的表，若查找的结点是表中第6个结点，则只需进行一次比较；若查找的结点是表中第3或第9个结点，则需进行二次比较；找第1，4，7，10个结点需要比较三次；找到第2，5，8，11个结点需要比较四次。
        　由此可见，成功的二分查找过程恰好是走了一条从判定树的根到被查结点的路径，经历比较的关键字次数恰为该结点在树中的层数。若查找失败，则其比较过程是经历了一条从判定树根到某个外部结点的路径，所需的关键字比较次数是该路径上内部结点的总数。
        【例】待查表的关键字序列为：(05，13，19，21，37，56，64，75，80，88，92)，若要查找K=85的记录，所经过的内部结点为6、9、10，最后到达方形结点"9-10"，其比较次数为3。
        　实际上方形结点中"i-i+1"的含意为被查找值K是介于R[i].key和R[i+1].key之间的，即R[i].key<K<R[i+1].key。
    二分查找的平均查找长度
         　设内部结点的总数为n=2h-1，则判定树是深度为h=lg(n+1)的满二叉树(深度h不计外部结点)。树中第k层上的结点个数为2k-1，查找它们所需的比较次数是k。因此在等概率假设下，二分查找成功时的平均查找长度为：
               ASLbn≈lg(n+1)-1
    　　二分查找在查找失败时所需比较的关键字个数不超过判定树的深度，在最坏情况下查找成功的比较次数也不超过判定树的深度。即为：
               
    　　二分查找的最坏性能和平均性能相当接近。

    二分查找的优点和缺点
    　　虽然二分查找的效率高，但是要将表按关键字排序。而排序本身是一种很费时的运算。既使采用高效率的排序方法也要花费O(nlgn)的时间。
    　　二分查找只适用顺序存储结构。为保持表的有序性，在顺序结构里插入和删除都必须移动大量的结点。因此，二分查找特别适用于那种一经建立就很少改动、而又经常需要查找的线性表。
    　　对那些查找少而又经常需要改动的线性表，可采用链表作存储结构，进行顺序查找。链表上无法实现二分查找。

    5. 带权树：

    即路径带有权值。例如：

     

    6. 最优树（赫夫曼树）：

     
    赫夫曼树：给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman tree)。即带权路径长度最短的树。
    赫夫曼树构造算法：
    假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为{ w1、w2、…、wn}，则哈夫曼树的构造规则为：　　(1) 将{w1、w2、…，wn}看成是有n 棵树的森林(每棵树仅有一个结点)；　　(2) 在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；　　(3)从森林中删除选取的两棵树，并将新树加入森林；　　(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。
     
    赫夫曼编码：是通信中最经典的压缩编码.
    其算法：
    stdafx.h文件：
    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. // stdafx.h : include file for standard system include files,  
    2. // or project specific include files that are used frequently, but  
    3. // are changed infrequently  
    4. //  
    5.   
    6. #pragma once  
    7.   
    8. #include <stdio.h>    
    9. #include "stdlib.h"  
    10. #include <iostream>  
    11. using namespace std;  
    12.   
    13.   
    14. //宏定义      
    15. #define TRUE   1      
    16. #define FALSE   0      
    17. #define OK    1      
    18. #define ERROR   0    
    19. #define INFEASIBLE -1      
    20. #define OVERFLOW -2    
    21. #define STACKEMPTY -3   
    22. #define QUEUEEMPTY  -3      
    23.   
    24. #define MAX 10 // MAXIMUM STACK CONTENT    
    25. #define MAX_QUEUE 10 // MAXIMUM QUEUE CONTENT    
    26.   
    27. typedef int Status;      
    28. typedef int ElemType;    
    29.   
    30. typedef struct{  
    31.     unsigned int weight;  
    32.     unsigned int parent, lchild,rchild;  
    33. }HTNode, *HuffmanTree;  //动态分配数组存储赫夫曼树  
    34.   
    35. typedef char * * HuffmanCode;//动态分配数组存储赫夫曼编码表  
    test.cpp文件：
    [cpp] view plain copy
     
     print?在CODE上查看代码片派生到我的代码片
    1. // Test.cpp : Defines the entry point for the console application.    
    2. //    
    3. #include "stdafx.h"    
    4.   
    5.   
    6.   
    7. /************************************************************************/  
    8. /* 算法： 
    9. */  
    10. /************************************************************************/  
    11.   
    12. void select(HuffmanTree &HT,int n,int &h1,int &h2)  
    13. {  
    14.     int i ,j;  
    15.   
    16.     for(i=1;i<=n;i++)  
    17.         if(!HT[i].parent)  //一旦找到父结点不为0的结点就停止  
    18.         {  
    19.             h1=i;       
    20.             break;  
    21.         }  
    22.         for(j=i+1;j<=n;j++)  
    23.             if(!HT[j].parent)  
    24.             {  
    25.                 h2=j;  
    26.                 break;  
    27.             }  
    28.             for(i=1;i<=n;i++)  
    29.                 if(HT[h1].weight>HT[i].weight&&!HT[i].parent&&(h2!=i))  
    30.                     h1=i;   //进行比较，找权值最小，和h2不同的结点  
    31.             for(j=1;j<=n;j++)  
    32.                 if(HT[h2].weight>HT[j].weight&&!HT[j].parent&&(h1!=j))  
    33.                     h2=j;   //进行比较，找权值最小，和h1不同的结点  
    34.             if(h1>h2)  
    35.             {  
    36.                 int temp;    //将权值最小的结点赋给h1  
    37.                 temp=h1;  
    38.                 h1=h2;  
    39.                 h2=temp;  
    40.             }  
    41. }  
    42. /************************************************************************/  
    43. /* 
    44. w存放n 个字符的权值（均>0),构造赫夫曼树HT，并求出n 个字符的赫夫曼编码HC。 
    45. */  
    46. /************************************************************************/  
    47. void HuffmanCoding(HuffmanTree &HT, HuffmanCode &HC, int *w,int n)  
    48. {  
    49.     if(n<=1) return;  
    50.     int m,i;  
    51.     char *cd;  
    52.     int s1, s2;  
    53.     // HuffmanTree p;  
    54.     m = 2*n-1;  
    55.     HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));  //0号单元未用  
    56.     for (i=1; i<=n; i++) { //初始化,相当： p = HT; p = {*w, 0, 0,0 }， ++p;  
    57.         HT[i].weight=w[i-1];  
    58.         HT[i].parent=0;  
    59.         HT[i].lchild=0;  
    60.         HT[i].rchild=0;  
    61.     }  
    62.     for (i=n+1; i<=m; i++) { //初始化 p = {*w, 0, 0,0 }， ++p;  
    63.         HT[i].weight=0;  
    64.         HT[i].parent=0;  
    65.         HT[i].lchild=0;  
    66.         HT[i].rchild=0;  
    67.     }  
    68.   
    69.     //添加查看便于调试  
    70.     printf(" -------------------------------------------");  
    71.     printf(" 哈夫曼树的构造过程如下所示： ");  
    72.     printf("HT初态: ");  
    73.     printf(" 结点   weight  parent  lchild  rchild");  
    74.     for (i=1; i<=m; i++)  
    75.         printf(" %4d%8d%8d%8d%8d",i,HT[i].weight,HT[i].parent,HT[i].lchild, HT[i].rchild);  
    76.   
    77.     for (i=n+1; i<=m; i++) { // 建哈夫曼树  
    78.         // 在HT[1..i-1]中选择parent为0且weight最小的两个结点，  
    79.         // 其序号分别为s1和s2。  
    80.         select(HT, i-1,s1,s2);  
    81.         HT[s1].parent = i; HT[s2].parent = i;  
    82.         HT[i].lchild = s1; HT[i].rchild = s2;  
    83.         HT[i].weight = HT[s1].weight + HT[s2].weight;  
    84.         //添加查看，便于调试  
    85.         printf(" select: s1=%d s2=%d ", s1, s2);  
    86.         printf(" 结点   weight  parent  lchild  rchild");  
    87.         for (int j=1; j<=i; j++)  
    88.             printf(" %4d%8d%8d%8d%8d",j,HT[j].weight,  
    89.             HT[j].parent,HT[j].lchild, HT[j].rchild);  
    90.   
    91.     }  
    92.   
    93.     //---从叶子到根逆向求每个字符的赫夫曼编码---  
    94.     int start,f;  
    95.     unsigned int c;  
    96.     HC=(HuffmanCode)malloc((n+1)*sizeof(char *)); //分配n个字符编码的头指针向量  
    97.     cd=(char *)malloc(n*sizeof(char));     //分配求编码的工作空间  
    98.     cd[n-1]='';        //编码结束符  
    99.     for(i=1;i<=n;++i)  
    100.     {  
    101.         //逐个字符求赫夫曼编码  
    102.         start=n-1;  
    103.         for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到根逆向求编码  
    104.             if(HT[f].lchild==c)  
    105.                 cd[--start]='0';  
    106.             else  
    107.                 cd[--start]='1';  
    108.         HC[i]=(char *)malloc((n-start)*sizeof(char)); //为第i个字符编码分配空间  
    109.         strcpy(HC[i],&cd[start]);  //从cd复制编码到HC  
    110.     }  
    111.     free(cd);  //释放工作区间  
    112. }  
    113. void main()  
    114. {  
    115.     HuffmanTree HT; HuffmanCode HC; int *w,n,i;  
    116.     printf("输入结点数： ");  
    117.     scanf("%d",&n);  
    118.     HC=(HuffmanCode)malloc(n*sizeof(HuffmanCode));  
    119.     w=(int *)malloc(n*sizeof(int));  
    120.     printf("输入%d个结点的权值: ",n);  
    121.     for(i=0;i<n;i++)  
    122.         scanf("%d",&w[i]);  
    123.     HuffmanCoding(HT,HC,w,n);  
    124.     printf(" ------------------------------------------- ");  
    125.     printf(" 各结点的赫夫曼编码: ");  
    126.     printf("编号  权值  编码 ");  
    127.     for(i=1;i<=n;i++)  
    128.         printf("%2d,%6d:%6s ",i,w[i-1],HC[i]);  
    129.   
    130. }  
  • 相关阅读:
    winsows10 小技巧
    数组与智能指针
    卸载 VS2015
    Effective C++
    修改 git commit 的信息
    线程管理
    并发编程简介
    个别算法详解
    git 删除某个中间提交版本
    git 查看某一行代码的修改历史
  • 原文地址：https://www.cnblogs.com/timssd/p/5449997.html
Copyright © 2011-2022 走看看