2. 程式人生 > >使用優先隊列構建赫夫曼樹

使用優先隊列構建赫夫曼樹

阿新 • • 發佈：2017-05-19
tex encode b2c fontsize 結構 技術分享 abi enter row

關於赫夫曼編碼和赫夫曼樹的相關知識可參考之前兩篇文章（由二叉樹構造赫夫曼樹、赫夫曼編碼）。

本文介紹還有一種構建赫夫曼樹的方式，採用優先隊列.


步驟： 1.首先我們須要統計不同字符出現的次數。一個字符出現的次數越多，說明其優先級越高，其赫夫曼編碼應該越短； 2.將待編碼的字符（即帶權節點）存入優先級隊列，優先級即字符出現的次數； 3.不斷叠代隊列，直到隊列中剩下一個元素（即根節點）。每次從隊列中取出兩個優先級最小的元素（優先級隊列中的元素是依照節點優先級順序排列的），然後生成一個新的赫夫曼樹節點，節點左右孩子分別指向這兩個元素，節點權值為這兩個元素權值之和。將新節點插入隊列; 4.依據赫夫曼樹生成赫夫曼編碼表。遞歸遍歷赫夫曼樹，對每一個葉子節點進行編碼(左0右1); 5.編碼過程即對每一個字符查編碼表的過程; 6.解碼過程即依據編碼串訪問赫夫曼樹的過程.
實現：

 
/*****************************************************
赫夫曼編碼優先隊列版
by Rowandjj
2014/6/17
*****************************************************/
#include<iostream>
using namespace std;


typedef struct _HTNODE_//赫夫曼樹節點的存儲結構
{
    char symbol;//符號(ASC碼值)
    struct _HTNODE_ *left;//左孩子
    struct _HTNODE_ *right;//右孩子
}HtNode;

typedef struct _HTREE_//赫夫曼樹
{
    HtNode *root;
}HTree;

typedef struct _HLNODE_//赫夫曼碼表節點
{
    char symbol;//ASC碼值
    char *code;//相應的編碼
    struct _HLNODE_ *next;
}HlNode;

typedef struct _HLTABLE_//赫夫曼碼表(以單鏈表形式存儲不同ASC碼及與之相應的編碼表)
{
    HlNode *first;
    HlNode *last;
}HlTable;
//--------------------------------------------------------
#define MAX_SZ 256//隊列最大長度
#define TYPE HtNode*//優先隊列的節點定義
typedef struct _PQUEUENODE_//隊列節點定義
{
    TYPE val;//節點值
    unsigned int priority;//優先級
    struct _PQUEUENODE_ *next;
}pQueueNode;

typedef struct _PQUEUE_//優先隊列定義
{
    unsigned int size;//隊列長度
    pQueueNode *first;//首節點
}pQueue;
//-----------優先隊列操作定義------------------------------
void InitQueue(pQueue **queue);//隊列初始化
void AddQueue(pQueue **queue,TYPE val,unsigned int priority);//將一個帶優先級的節點插入隊列
TYPE GetQueue(pQueue **queue);//隊列節點依照優先級順序出隊
void TraverseQueue(pQueue *queue);//遍歷隊列

//-----------赫夫曼編碼操作定義----------------------------
HTree* BuildTree(char *inputString);//創建赫夫曼樹
HlTable* BuildTable(HTree *huffmanTree);//構建赫夫曼碼表（出現頻率最高的ASC碼將使用最短的編碼）
void encode(HlTable *table,char *stringToEncode);//編碼
void decode(HTree *tree,char *stringToDecode);//解碼
void TraverseTable(HlTable *table);//遍歷赫夫曼編碼表
//---------------------------------------------------------

void InitQueue(pQueue **queue)
{
    *queue = (pQueue *)malloc(sizeof(pQueue));
    (*queue)->first = NULL;
    (*queue)->size = 0;
}

void AddQueue(pQueue **queue,TYPE val,unsigned int priority)
{
    if((*queue)->size == MAX_SZ)
    {
        cout<<"queue is full!";
        return;
    }
    pQueueNode *aux = (pQueueNode*)malloc(sizeof(pQueueNode));
    aux->priority = priority;
    aux->val = val;
    aux->next = NULL;

    if((*queue)->first == NULL)//生成隊列首節點
    {
        (*queue)->first = aux;
        (*queue)->size++;
    }else
    {
        if(priority <= (*queue)->first->priority)//插到首節點位置
        {
            aux->next = (*queue)->first;
            (*queue)->first = aux;
            (*queue)->size++;
        }else//遍歷隊列插到合適的位置
        {
            pQueueNode *iterator = (*queue)->first;
            

            while(iterator->next != NULL && priority > iterator->next->priority)
            {
                iterator = iterator->next;
            }

            aux->next = iterator->next;
            iterator->next = aux;
            (*queue)->size++;
        }
    }
}

TYPE GetQueue(pQueue **queue)
{
    TYPE returnVal = NULL;
    if ((*queue)->size > 0)
    {
        pQueueNode *nodeToDel = (*queue)->first;
        (*queue)->first = (*queue)->first->next;
        returnVal = nodeToDel->val;
        free(nodeToDel);
        (*queue)->size--;
    }else
    {
        cout<<"queue is empty"<<endl;
    }
    return returnVal;
}
//-------------------------------------------------------------
HTree* BuildTree(char *inputString)
{
    //統計字符出現次數
    int *probability = (int*)malloc(sizeof(int)*256);
    int i;
    for(i = 0; i < 256;i++)
    {
        probability[i] = 0;
    }
    for(i = 0; inputString[i] != ‘\0‘;i++)
    {
        probability[(unsigned char)inputString[i]]++;
    }
    
/*    for(i = 0; i < 256; i++)//打印字符出現的次數(也即頻率)
    {
        if(probability[i] != 0)
        cout<<(char)i<<":"<<probability[i]<<endl;
    }
*/
    //依據每一個字符出現的頻率生成赫夫曼樹
    pQueue* huffmanQueue;
    InitQueue(&huffmanQueue);
    for(i = 0; i < 256; i++)
    {
        //1 現將帶權節點加到隊列中
        if(probability[i] != 0)//僅僅考慮帶權節點,也就是說僅僅對帶權節點編碼
        {
            HtNode *aux = (HtNode*)malloc(sizeof(HtNode));
            aux->symbol = (char)i;
            aux->left = NULL;
            aux->right = NULL;
            
            AddQueue(&huffmanQueue,aux,probability[i]);
        }
    }
    
    cout<<"字符及出現頻次："<<endl;
    TraverseQueue(huffmanQueue);
    free(probability);
        //2 再構建赫夫曼樹
    while(huffmanQueue->size != 1)
    {
        int priority = huffmanQueue->first->priority;
        priority += huffmanQueue->first->next->priority;
        //從隊列中獲取兩個優先級最低的節點
        HtNode *left = GetQueue(&huffmanQueue);
        HtNode *right = GetQueue(&huffmanQueue);
        //生成其父節點，父節點的權值為兩個子節點的權值之和
        HtNode *newNode = (HtNode*)malloc(sizeof(HtNode));
        newNode->left = left;
        newNode->right = right;
        //將生成的父節點插入到優先隊列的合適位置
        AddQueue(&huffmanQueue,newNode,priority);
    }
    HTree *tree = (HTree*)malloc(sizeof(HTree));
    tree->root = GetQueue(&huffmanQueue);
    return tree;
}
void travelseTree(HtNode *treeNode,HlTable **table,int k,char code[256])
{
    if(treeNode->left == NULL && treeNode->right == NULL)//走到葉子節點
    {
        code[k] = ‘\0‘;
        HlNode *aux = (HlNode*)malloc(sizeof(HlNode));
        aux->symbol = treeNode->symbol;
        aux->code = (char *)malloc(sizeof(char)*(strlen(code)+1));
        strcpy(aux->code,code);
        aux->next = NULL;
        if((*table)->first == NULL)//連接
        {
            (*table)->first = (*table)->last = aux;
        }else
        {
            (*table)->last->next = aux;
            (*table)->last = aux;
        }
    }
    if(treeNode->left != NULL)
    {
        code[k] = ‘0‘;
        travelseTree(treeNode->left,table,k+1,code);
    }
    if(treeNode->right != NULL)
    {
        code[k] = ‘1‘;
        travelseTree(treeNode->right,table,k+1,code);
    }
}
HlTable* BuildTable(HTree *huffmanTree)//由赫夫曼樹構建赫夫曼編碼表
{
    HlTable *table = (HlTable*)malloc(sizeof(HlTable));
    table->first = NULL;
    table->last = NULL;
    char code[256];
    int k = 0;
    
    travelseTree(huffmanTree->root,&table,k,code);
    return table;
}

void encode(HlTable *table,char *stringToEncode)
{
    HlNode *travel;

    for(int i = 0; stringToEncode[i] != ‘\0‘; i++)
    {
        travel = table->first;
        while(travel->symbol != stringToEncode[i])
        {
            travel = travel->next;
        }
        cout<<travel->code<<"  ";
    }
}
void decode(HTree *tree,char *stringToDecode)
{
    HtNode *travel = tree->root;
    for(int i = 0;stringToDecode[i] != ‘\0‘; i++)
    {
        if(travel->left == NULL && travel->right == NULL)
        {
            cout<<travel->symbol;
            travel = tree->root;
        }
        if(stringToDecode[i] == ‘0‘)
        {
            travel = travel->left;
        }
        if(stringToDecode[i] == ‘1‘)
        {
            travel = travel->right;
        }
        if(stringToDecode[i] != ‘0‘ && stringToDecode[i] != ‘1‘)
        {
            cout<<"\ndecode error..."<<endl;
        }
    }
    if(travel->left == NULL && travel->right == NULL)
    {
        cout<<travel->symbol;
        travel = tree->root;
    }

}

void TraverseQueue(pQueue *queue)
{
    pQueueNode *iterator = queue->first;
    while(iterator != NULL)
    {
        cout<<iterator->val->symbol<<":"<<iterator->priority<<endl;
        iterator = iterator->next;
    }
}
void TraverseTable(HlTable *table)
{
    HlNode *iterator = table->first;
    cout<<"字符"<<":"<<"編碼"<<endl;
    while(iterator != NULL)
    {
        cout<<iterator->symbol<<":"<<iterator->code<<endl;
        iterator = iterator->next;
    }
    cout<<endl;
}
int main()
{
    HTree *codeTree = BuildTree("abbccccddddddd");
    HlTable *codeTable = BuildTable(codeTree);
    
    TraverseTable(codeTable);
    cout<<"編碼開始:"<<endl;
    encode(codeTable,"abcd");
    cout<<"\n解碼開始:"<<endl;
    decode(codeTree,"10100100000101");
    cout<<endl;
    return 0;
}

測試結果：
技術分享
優先隊列變化過程：
 技術分享
 生成的赫夫曼樹：
技術分享
 註：這裏的構建赫夫曼樹的約定和之前的兩篇不太一樣，這裏約定一個節點的左節點的權值小於右節點的權值.

使用優先隊列構建赫夫曼樹

相關推薦

使用優先隊列構建赫夫曼樹

tex encode b2c fontsize 結構 技術分享 abi enter row 關於赫夫曼編碼和赫夫曼樹的相關知識可參考之前兩篇文章（由二叉樹構造赫夫曼樹、赫夫曼編碼）。本文介紹還有一種構建赫夫曼樹的方式，採用優先隊列. 步驟： 1.首先我們須要統

赫夫曼樹的構建、編碼、譯碼解析

fmt 獲取 插入 typedef child 構造方法 clas name lin 當你開始看這篇博文的時候。我相信你對樹及二叉樹的基本概念已有所了解。我在這裏就不再贅述。我們主要對赫 夫曼樹的特點、構建、編碼、譯碼做一個具體的介紹，並附有代碼，全部函數

java使用優先級隊列實現哈夫曼編碼

哈夫曼編碼 左右 integer string enc ash 小根堆 rac sta 思路： 構建小根堆 根據小根堆實現哈夫曼樹 根據哈夫曼樹對數據進行編碼 代碼實現如下： /** * @Author: DaleyZou * @Description: 使用jav

DS二叉樹--赫夫曼樹的構建與編碼

題目描述 給定n個權值，根據這些權值構造huffman樹，並進行huffman編碼 參考課本演算法，注意陣列訪問是從位置1開始 要求：赫夫曼的構建中，預設左孩子權值不大於右孩子權值 輸入 第一行輸入t，表示有t個測試例項 第二行先輸入n，表示第1個例項有n個權

最優二叉樹（赫夫曼樹）的構建

一、構建最優二叉樹 ①、節點類：五個屬性：結點的資料、父結點、左子結點、右子結點、赫夫曼編碼 /** * 樹的結點類 * * @author lenovo * */ public class TreeNode { private Object obj;

c語言實現赫夫曼樹的構建以及生成赫夫曼編碼（《資料結構》演算法6.12）

這個程式是根據《資料結構》演算法6.12用c語言實現的程式，赫夫曼樹就不多說了，直接看程式碼，程式碼上都有註釋。 下面程式碼： #include<stdio.h> #include<iostream> #include<stdlib.h>

由二叉樹構造赫夫曼樹

family 如果 csdn img log ret iss struct center 赫夫曼樹： 如果有n個權值{w1,w2,w3....},試構造一棵具有n個葉子節點的二叉樹，每一個葉子節點帶權為wi。則當中帶權路徑長度最小的二叉樹稱為最優二叉樹或者叫赫夫曼樹。

php 二叉樹 與赫夫曼樹

二叉樹 赫夫曼樹 在學習圖之前，中間休息了兩天，感覺二叉樹需要消化一下。所以中間去溫習了下sql，推薦一本工具書《程序員的SQL金典》看名字不像一本好書，但是作為一個不錯的SQL工具書還是可以小小備忘一下。涵蓋內容不詳細但是挺廣，覆蓋多種主流數據庫言歸正傳，以前知道折半查找，二叉樹的概念也是感覺挺有意

赫夫曼樹編碼解碼實例(C)

sta nod 輸入 sign 赫夫曼 spa 字符數組 ++ es2017 //HuffmanTree.h #include <stdlib.h> #include <stdio.h> #include <string.h> #def

數據結構中赫夫曼樹

數據結構赫夫曼樹 以下程序在效率上有什麽問題？ 上述代碼的流程圖： 如果我們把判斷流程改成下面的樣子，大家思考一下，比起上一種哪個好點？ 赫夫曼樹的定義與原理：我們先把這兩顆二叉樹簡化成為葉子節點帶權的二叉樹。註：樹節點間的連線相關的數叫做權。 節點的路勁長度：——從根節點到該節點的路徑上的連線數。樹的

從頭結點開始編碼的赫夫曼樹

str style struct tarray enum tdi color num 輸入 #include<stdio.h> #include<string.h> #include<stdlib.h> #ifndef MACRO_/

赫夫曼（赫夫曼樹、最優樹、赫夫曼編碼）

赫夫曼樹，別名“哈夫曼樹”、“最優樹”以及“最優二叉樹”。學習哈夫曼樹之前，首先要了解幾個名詞。 哈夫曼樹相關的幾個名詞 路徑：在一棵樹中，一個結點到另一個結點之間的通路，稱為路徑。圖 1 中，從根結點到結點 a 之間的通路就是一條路徑。 路徑長度：在一條路徑中，每經過一個結點，路徑長度都要

有趣的赫夫曼樹

bcd 根節點 數字 sum obj 基本 重復 adf 表示 美國有個數學家叫赫夫曼，60年前他根據數據的使用概率，發明了一個二叉樹叫赫夫曼樹。 這個赫夫曼樹被用在了數據壓縮上，被稱為赫夫曼編碼，這是後來壓縮的基礎。 他解決的問題主要思想是：根據元素出現的概率，獲得最

赫夫曼樹-Huffman編碼

首先感嘆，Huffman真牛逼！！ 儘量把檔案壓縮到最小 通過最優排序，大資料把人們最常用的字元放到樹前面，以實現最小編碼。 大致說一下原理，貼一下程式碼 1：使用者提供常用字元，建立一棵最優樹 2：得到每一個字元的編碼code 3：使用者輸入0和1，通過遍歷最優

Java資料結構和演算法（四）赫夫曼樹

Java資料結構和演算法（四）赫夫曼樹 哈夫曼樹又稱為最優二叉樹，赫夫曼樹的一個最主要的應用就是哈夫曼編碼。 一、赫夫曼樹 can you can a can as a can canner can a can. 1.1 定長編碼 99 97 110 32 121 111 117 32 99 97

赫夫曼樹-赫夫曼編碼

赫夫曼樹，又稱最優樹，是一類帶權路徑長度最短的樹，有著廣泛的應用。 設二叉樹具有n個帶權值的葉子結點，從根結點到各個葉子結點的路徑長度與對應葉子結點權值的乘積之和叫做二叉樹的帶權路徑長度。 對於一組帶有確定權值的葉子結點，帶權路徑長度最小的二叉樹稱為最優二叉樹。 構造赫

Android版資料結構與演算法(七):赫夫曼樹

近期忙著新版本的開發，此外正在回顧C語言，大部分時間沒放在資料結構與演算法的整理上，所以更新有點慢了，不過既然寫了就肯定盡力將這部分完全整理好分享出來。 言歸正傳，開啟本篇的正文。 一、什麼是赫夫曼樹 給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也

赫夫曼樹的建立

赫夫曼樹，即最優二叉樹。 給定n個權值作為n個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度達到最小，稱這樣的二叉樹為最優二叉樹，也稱為哈夫曼樹(Huffman Tree)。哈夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近。 構造赫夫曼樹： 把節點

用連結串列的方式構建哈夫曼樹

#include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std; #define MAXSIZE 30 typedef struct node {  

資料結構之赫夫曼樹的演算法介紹和實現

一、基礎知識： （1）最優二叉樹（赫夫曼樹）的介紹： a、路徑長度：從樹中一個結點到另一個結點之間的分支構成這兩個結點之間的路徑，路徑上分支數目稱做路徑長度。 b、樹的路徑長度：從樹根到每一個結點之間的路徑長度之和。上一篇介紹的完全二叉樹就是這種路徑長度最短的二叉樹。 c、