哈夫曼樹的建立和操作

阿新 • • 發佈：2018-12-22

哈夫曼樹的引進是與帶有權重的二叉樹有關的
首先定義帶權路徑長度（WPL）：設二叉樹有n個葉子結點，每個葉子結點帶有權值Wk，從根結點到每個葉子的長度為Ik，則每個葉子結點的帶權路徑長度之和就是：WPL=∑nk=1wklk。
最優二叉樹或哈夫曼樹：WPL最小的二叉樹

哈夫曼樹

那麼如何建立一棵哈夫曼樹呢，哈夫曼提出了一種方法，就是每次把權值最小的兩棵二叉樹合併，例如下圖所示

Huffman樹的例子

這就可以用到堆，每次把新生成的樹插入進堆，然後彈出兩個樹依次就是最小的樹，揭下來就是具體的實現了，首先是把之前的最小堆改為最大堆，然後把Elements的型別改掉，最後是寫Huffman樹

#include <stdio.h>     

#include <stdlib.h>    

#define MinData -1000;

#define ERROR -1; /* 錯誤標識應根據具體情況定義為堆中不可能出現的元素值 */  

struct TreeNode{
    int Weight;
    TreeNode *Left;
    TreeNode *Right;
};
typedef struct TreeNode *HuffmanTree;  
typedef HuffmanTree ElementType;   
struct HeapStruct{    
    ElementType *Elements;//儲存堆元素的陣列     

    int Size;//堆的當前元素個數  
    int Capacity;//堆的最大容量  
};
typedef struct HeapStruct *MinHeap;  



//建立容量為MinSize的空的最小堆  
MinHeap Create(int MinSize);  
//判斷最小堆是否已滿  
int IsFull(MinHeap H);  
//最小堆的插入  
void Insert(MinHeap &H,ElementType item);  
//判斷最小堆是否為空  
int IsEmpty(MinHeap H);  
//從堆中刪除一個元素  
ElementType DeleteMin(MinHeap H);  
//建造最小堆 

void PercDown( MinHeap H, int p );  
void BuildHeap( MinHeap H );  
//列印堆中元素  
void Print(MinHeap H);


//建立Huffman樹
HuffmanTree Huffman(MinHeap H);

//遍歷樹
 void preOrder(HuffmanTree t);  //先序遍歷   
 void intOrder(HuffmanTree t);  //中序遍歷    
 void postOrder(HuffmanTree t);  //後序遍歷    

int main(){  


     MinHeap H= Create(15);  
    int a[]={1,2,3,4,5};  
    int len=sizeof(a)/sizeof(int);  
    H->Size=len;  
    for(int i=0;i<len;i++)  
        H->Elements[i+1]->Weight=a[i];

    Print(H);  
    HuffmanTree T;
    T=Huffman(H);
    printf("前序遍歷：");  
   preOrder(T) ;  
   printf("\n");  
   printf("中序遍歷：");  
   intOrder(T);  
   printf("\n");  
   printf("後序遍歷：");    
   postOrder(T);    
   printf("\n");   


    system("pause");  
}  

//建立容量為MinSize的空的最小堆  
MinHeap Create(int MinSize){  
    MinHeap H=(MinHeap)malloc(sizeof(struct HeapStruct));  
    H->Elements=(ElementType *)malloc((MinSize+1)*sizeof(ElementType));//從小標為1的地方開始存放

    //for(int i=0;i<=MinSize;i++)
        //H->Elements[i]=(HuffmanTree)malloc(sizeof(TreeNode));
    for(int i=0;i<=MinSize;i++)
    {
        H->Elements[i]=(ElementType )malloc(sizeof(ElementType));//從小標為1的地方開始存放
        H->Elements[i]->Weight=0;//定義“哨兵”為大於堆中所有可能元素的值，便於以後更快操作
        H->Elements[i]->Left=NULL;
        H->Elements[i]->Right=NULL;
    }

    H->Size=0;  
    H->Capacity=MinSize;  
    H->Elements[0]->Weight=MinData;//定義“哨兵”為大於堆中所有可能元素的值，便於以後更快操作  

    return H;  
    //時間複雜性是O(logN)  
};  

//判斷最小堆是否已滿  
int IsFull(MinHeap H){  
    return(H->Size==H->Capacity);  
};  


//最小堆的插入  
void Insert(MinHeap &H,ElementType item)  
{//將元素item插入最小堆H，其中H->Elements[0]已經定義為哨兵  
    int i;  
    if(IsFull(H)){
        printf("最小堆已滿\n");
        return;
    }
    i=++H->Size;//先Size自加1再賦給i，i指向插入後堆中的最後一個元素  
    for(;H->Elements[i/2]->Weight>item->Weight;i/=2)  
        H->Elements[i]=H->Elements[i/2];//向下過濾結點  
    //哨兵的作用就是避免插入的值比Elements[0]還小  
    H->Elements[i]=item;//將item插入,執行速度比交換快  
    //時間複雜性是O(logN)  
};  


//判斷最小堆是否為空  
int IsEmpty(MinHeap H){  
    return(H->Size==0);   
};  

//從堆中刪除一個元素  
ElementType DeleteMin(MinHeap H){//從最小堆H中取出鍵值最小的元素，並刪除一個結點  
    int Parent,Child;  
    ElementType MinItem,temp;  
    if(IsEmpty(H)){  
        printf("最小堆已為空\n");  
        return NULL;  
    }  
    MinItem=H->Elements[1];//取出根節點（最小值）  
    //用最小堆中的最後一個元素從根節點開始向上過濾下層結點  
    temp=H->Elements[H->Size--];  
    for(Parent=1;Parent*2<=H->Size;Parent=Child){  
        Child=Parent*2;  
        if((Child!=H->Size)&&(H->Elements[Child]->Weight>H->Elements[Child+1]->Weight))  
            Child++;//Child指向左右子結點中較小的  
        if(temp->Weight<=H->Elements[Child]->Weight)break;  
        else//移動temp到下一層  
            H->Elements[Parent]=H->Elements[Child];  
    }  
    H->Elements[Parent]=temp;  
    return MinItem;  
}  


/*----------- 建造最小堆 -----------*/  
void PercDown( MinHeap H, int p )  
{ /* 下濾：將H中以H->Data[p]為根的子堆調整為最小堆 */  
    int Parent, Child;  
    ElementType X= H->Elements[p]; /* 取出根結點存放的值 */  
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {  
        Child = Parent * 2;  
        if( (Child!=H->Size) && (H->Elements[Child]->Weight>H->Elements[Child+1]->Weight) )  
            Child++;  /* Child指向左右子結點的較小者 */  
        if( X->Weight <= H->Elements[Child]->Weight ) break; /* 找到了合適位置 */  
        else  /* 下濾X */  
            H->Elements[Parent] = H->Elements[Child];  
    }  
    H->Elements[Parent] = X;  
}  

void BuildHeap( MinHeap H )  
{ /* 調整H->Data[]中的元素，使滿足最小堆的有序性  */  
  /* 這裡假設所有H->Size個元素已經存在H->Data[]中 */  

    int i;  

    /* 從最後一個結點的父節點開始，到根結點1 */  
    for( i = H->Size/2; i>0; i-- )  
        PercDown( H, i );  
}  

//列印堆中元素  
void Print(MinHeap H){  
    printf("H中的元素為：\n");  
    for(int i=1;i<=H->Size;i++)  
        printf("%d ",H->Elements[i]->Weight);  
    printf("\n");  
}

//建立Huffman樹
HuffmanTree Huffman(MinHeap H){
    //假設H->Size個權值已經存在H->Elements[]->Weight裡
    int i;HuffmanTree T;
    BuildHeap(H);//將堆調整為最小堆
    int len=H->Size;
    for(i=1;i<len;i++){//做H->Size-1次合併
        T=(HuffmanTree)malloc(sizeof(struct TreeNode));//建立新結點
        T->Left=DeleteMin(H);
        T->Right=DeleteMin(H);
        T->Weight=T->Left->Weight+T->Right->Weight;
        Insert(H,T);
    }
    T=DeleteMin(H);
    return T;
};

//遍歷樹
 void preOrder(HuffmanTree t)  //先序遍歷   
 {    
     if(t)    
     {      
         printf("%d ",t->Weight);    
         preOrder(t->Left);    
         preOrder(t->Right);    
     }    
 }    

 void intOrder(HuffmanTree t)  //中序遍歷    
{    
    if(t)    
     {    
        intOrder(t->Left);    
        printf("%d ",t->Weight);    
        intOrder(t->Right);    
     }    
 }    

 void postOrder(HuffmanTree t)  //後序遍歷    
 {    
     if(t)    
     {       
         postOrder(t->Left);    
         postOrder(t->Right);   
         printf("%d ",t->Weight);    
     }    
 }

重點有這麼兩個地方

MinHeap Create(int MinSize){  
    MinHeap H=(MinHeap)malloc(sizeof(struct HeapStruct));  
    H->Elements=(ElementType *)malloc((MinSize+1)*sizeof(ElementType));//從小標為1的地方開始存放

    //for(int i=0;i<=MinSize;i++)
        //H->Elements[i]=(HuffmanTree)malloc(sizeof(TreeNode));
    for(int i=0;i<=MinSize;i++)
    {
        H->Elements[i]=(ElementType )malloc(sizeof(ElementType));//從小標為1的地方開始存放
        H->Elements[i]->Weight=0;//定義“哨兵”為大於堆中所有可能元素的值，便於以後更快操作
        H->Elements[i]->Left=NULL;
        H->Elements[i]->Right=NULL;
    }

    H->Size=0;  
    H->Capacity=MinSize;  
    H->Elements[0]->Weight=MinData;//定義“哨兵”為大於堆中所有可能元素的值，便於以後更快操作  

    return H;  
    //時間複雜性是O(logN)  
};

一個是這裡建立時的malloc竟然有三次。。還是請同學幫我解決的

另外一個是下面Huffman樹的生成函式

HuffmanTree Huffman(MinHeap H){
    //假設H->Size個權值已經存在H->Elements[]->Weight裡
    int i;HuffmanTree T;
    BuildHeap(H);//將堆調整為最小堆
    int len=H->Size;
    for(i=1;i<len;i++){//做H->Size-1次合併
        T=(HuffmanTree)malloc(sizeof(struct TreeNode));//建立新結點
        T->Left=DeleteMin(H);
        T->Right=DeleteMin(H);
        T->Weight=T->Left->Weight+T->Right->Weight;
        Insert(H,T);
    }
    T=DeleteMin(H);
    return T;
};

下面是實現效果
這裡寫圖片描述

最後附上一段小程式碼

//整數轉化為樹之後再插入
void Insertint(MinHeap &H,int item){
    int i;
    if(IsFull(H)){
        printf("最小堆已滿\n");
        return;
    }
    i=++H->Size;//先Size自加1再賦給i，i指向插入後堆中的最後一個元素
    ElementType E1=(ElementType )malloc(sizeof(ElementType));
    E1->Right=E1->Left=NULL;
    E1->Weight=item;
    for(;H->Elements[i/2]->Weight>E1->Weight;i/=2)  
        H->Elements[i]=H->Elements[i/2];//向下過濾結點  
    //哨兵的作用就是避免插入的值比Elements[0]還小  
    H->Elements[i]=E1;//將item插入,執行速度比交換快  
    //時間複雜性是O(logN)  
};

這樣就可以呼叫

  MinHeap H= Create(15);

    Insertint(H,55);  
    Insertint(H,79);  
    Insertint(H,66);  
    Insertint(H,83);  
    Insertint(H,72);  
    Insertint(H,30);  
    Insertint(H,49);  
    Insertint(H,91);  
    Insertint(H,87);  
    Insertint(H,43);  
    Insertint(H,9);  
    Insertint(H,38);  
    Print(H);  
    DeleteMin(H);  
    DeleteMin(H);  
    Print(H);

等語句，哦耶終於完成啦^^

哈夫曼樹建立演算法

哈夫曼樹的建立 Problem Description 由若干個值無重複的結點及其權值，建立相應的哈夫曼樹。在合併過程中，若出現權值相同的情況，則優先選取編號小的進行合併；要求哈夫曼樹中所有左孩子編號小於右孩子編號（以結點的輸入順序做為其編號）。 Input

哈夫曼樹建立與求最短帶權路徑長度

#include<stdio.h> #include<stdlib.h> #define n 7 //假設有七個節點元素 struct Element { int flag; int weig

哈夫曼樹結構和帶權路徑長度計算

什麼是哈夫曼樹呢？哈夫曼樹是一種帶權路徑長度最短的二叉樹，也稱為最優二叉樹。下面用一幅圖來說明。它們的帶權路徑長度分別為：圖a： WPL=5*2+7*2+2*2+13*2=54 圖b： WPL=5*3+2*3+7*2+13*1=48 可見，圖b的

哈夫曼樹的建立和操作

哈夫曼樹的引進是與帶有權重的二叉樹有關的首先定義帶權路徑長度（WPL）：設二叉樹有n個葉子結點，每個葉子結點帶有權值Wk，從根結點到每個葉子的長度為Ik，則每個葉子結點的帶權路徑長度之和就是：WPL=∑nk=1wklk。最優二叉樹或哈夫曼樹：WPL最小的

哈夫曼樹的建立和編碼

// HuffmanTree.cpp : 定義控制檯應用程式的入口點。 #include "stdafx.h" #include <stdlib.h> #include <stdio.h> #include <string.h> typedef struct

非遞歸建立哈夫曼樹

push namespace i++ ren clas class ace %d 遞歸 #include<vector> #include<cstdio> #include<iostream> #include<algorithm

哈夫曼樹的建立

eof data scan 最小保存下標 all include urn 閑暇的夜晚，寫個哈夫曼樹練練筆。 #include<iostream>#include<cstring>#include<cstdlib>#inclu

轉載：哈夫曼樹的構造和哈夫曼編碼（C++代碼實現）

作者 pos blank 字符 element start man null == 作者：qiqifanqi 原文：http://blog.csdn.net/qiqifanqi/article/details/6038822 #include<stdio.h>

資料結構——第二章樹和森林：04哈夫曼樹與哈夫曼編碼

1.結點的路徑長度：從根結點到該結點的路徑上分支的數目。 2.樹的路徑長度：樹中每個結點的路徑長度之和。 3.樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度之和WPL(T) = ∑wklk（對所有葉子結點） 4.最優樹：在所有含n個結點，並帶相同權值的m叉樹中，必存在一棵其帶權路徑長度取最小值的樹，稱

數據結構——第二章樹和森林：04哈夫曼樹與哈夫曼編碼

一個例如 stat state 森林 ont 技術圖片 http 1.結點的路徑長度：從根結點到該結點的路徑上分支的數目。 2.樹的路徑長度：樹中每個結點的路徑長度之和。 3.樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度之和WPL(T) = ∑wklk（對所有葉子結

哈夫曼樹檔案操作

#include<bits/stdc++.h> using namespace std; int b[26]={0}; int bb[26]={0}; int kk; struct node{ int w; int p,l,r; }; set <node>

哈夫曼樹的建立及編碼

哈夫曼樹的建立：給n個葉子節點及權值，把n個葉子節點看成n個樹，由他們組成了森林，每次在森林中找到最小的兩個節點，把他們作為新樹的左子樹右子樹，並把這兩個節點從森林中刪除，把新樹節點加進森林，重複操作直到森林中剩餘一個或更少的節點；哈夫曼樹編碼：從根節點開始，按左子樹為'0',右子

哈夫曼樹及哈夫曼編碼和解碼

哈夫曼樹，又稱最優樹，是帶權路徑最小的樹。基本概念：節點間的路徑長度：兩個節點間所包含的邊的數目。樹的路徑長度：從根到樹中任意節點的路徑長度之和。權：將節點賦予一定的量值，該量值成為權。樹的帶權路徑長度：樹中所有葉子結點的帶權路徑長度。哈夫曼演算法：給定一個儲存權值的陣列，求

樹：哈夫曼樹的建立與編碼解碼

哈夫曼樹哈夫曼樹即最優二叉樹，演算法如下：（1）在當前未使用結點中找出兩個權重最小的作為左右孩子，計算出新的根結點（2）新的根結點繼續參與過程（1），直至所有結點連線為一棵樹如下圖，symbol為具體字元，Frequency為出現頻率（權重）特點：只有度數為

哈夫曼樹詳細講解（帶例題和C語言程式碼實現——全註釋）

** 哈夫曼樹詳細講解（帶例題和C語言程式碼實現——全註釋） ** 定義哈夫曼樹又稱最優二叉樹，是一種帶權路徑長度最短的二叉樹。所謂樹的帶權路徑長度，就是樹中所有的葉結點的權值乘上其到根結點的路徑長度（若根結點為0層，葉結點到根結點的路徑長度為葉結點

##資料結構##如何建立一棵哈夫曼樹並實現堆

哈夫曼樹是一種二叉樹，但是它是一種加權路徑長度最短的二叉樹。其可用堆來實現它的構建其構建方法如下：//heap.h //仿函式 template<class T> struct Less { bool operator()(const T& left,

哈夫曼樹的基本構建與操作

看到的講解huffman樹的一篇比較好懂的部落格出處:http://blog.csdn.net/wtfmonking/article/details/17150499# 1、基本概念 a、路徑和路徑長度若在一棵樹中存在著一個結點序列 k1，k2，……，kj，使得 k

圖示建立哈夫曼樹的過程

字元編碼：計算機裡每個字元在沒有壓縮的文字檔案中由一個直接（如常見的ASCII碼）或兩個直接（如比較新的Unicode,它可以在各種語言中通用）表示，在這些方案中，每個字元需要相同的位數。下圖列出裡用ASCII碼錶示的一些字元，可以看到每個字元都用8個位來表

哈夫曼樹和哈夫曼編碼

image bsp alt ima 技術分享 img http 哈夫曼 info 哈夫曼樹和哈夫曼編碼

資料結構與演算法 -- 哈夫曼樹思想與建立詳解1

PS:什麼是哈夫曼樹？　　給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。計算規則：　　假設一組權值，一個權值是一個結點，12 &

哈夫曼樹的建立和操作

相關推薦