哈夫曼編碼和譯碼。將以前學的c++相關知識系統的用了一遍，反正是能想到啥，啥方便就用啥，但是說回來，也沒省多少事。反正比用c語言寫跟簡單一點。
先看題目原型吧！

假設某通訊報文的字符集由A,B,C,D,E,F這6個字元組成，它們在報文中出現的頻度（頻度均為整數值）。
(1)構造一棵哈弗曼樹，依次給出各字元編碼結果。
(2)給字串進行編碼。
(3)給編碼串進行譯碼。

規定：
構建哈弗曼樹時：左子樹根結點權值小於等於右子樹根結點權值。
生成編碼時：左分支標0，右分支標1。

輸入
第一行：依次輸入6個整數，依次代表A,B,C,D,E,F的頻度，用空格隔開。
第二行：待編碼的字串
第三行：待譯碼的編碼串
輸出
前6行依次輸出各個字元及其對應編碼，格式為【字元:編碼】（冒號均為英文符號）
第7行：編碼串
第8行：譯碼串
樣例輸入
3 4 10 8 6 5
BEE
0010000100111101
樣例輸出
A:000
B:001
C:10
D:01
E:111
F:110
001111111
BADBED
 

所用到的相關知識，最近學的智慧指標，迭代器，STL中的list連結串列，array陣列容器，繼承，就這些吧！我也不怎麼考慮演算法的優劣了。這感覺確實所用到的變數太多了。我得彙總一下~~~

以上為相關類和屬性，其中data類中

• a 字元出現的頻數
• ch 對應的字元
• s 編碼連結串列字元型別，左為0右為1
• hafu類中的方法全是靜態方法（通過類名來使用）

其中hafu類是繼承data類的。tag屬性是標記當前節點是否存在父節點，不存在為0，存在為l、p、r分別為左孩子下標有孩子下標，p為雙親下標。
首先初始化data連結串列，將字元該放入的放入，該置0的置0，接下來第一核心部分建樹。
難就難在找最小權值下標和次小權值下標，不管了，我的實現方法就是先在無父節點的節點中找最大值，並在findmax函式中記錄無父節點的節點個數，當個數為1時說明我們的樹已經建的差不多了，該收工了，否則，設定min等於那個最大值+1，然後在陣列中和其他節點權值比較，依據題目要求，讓左節點權值小於有節點權值，先獲得的最小權值的下標賦給kl，在第一趟迴圈完了後將以kl為下標的節點的tag置為1，它將是有爸爸的孩子啦！然後再在第二趟迴圈中招最小權值下標，賦給kr，然後就是哈夫曼演算法，讓父節點的做有孩子下標為kl，kr，讓孩子的父親節點的下標為新建立的節點的下標！樹的建立大致思路就是這樣。點到為止！

接下來就是編碼，這在哈夫曼樹演算法中不算核心，很簡單，就根據節點的個數，逐個遍歷，從第一個開始，按照父親節點的下標，然後依據父親節點的下標找到父親節點，然後，看父親節點的孩子下標，判斷當前節點的下標是父節點的左孩子還是右孩子，若是右孩子，往編碼連結串列中追加字元1，否則追加字元0，當遇到當前節點的父節點下標為0時，表示已經到樹頂了！然後將連結串列逆置，因為我們的編碼方向是從樹頂到根，逆置後才是當前節點真正的哈弗曼編碼，直接呼叫函式就行了。然後進行下一個節點的編碼！同樣的方法！

在我看來，最難得就是譯碼了，真是很燒腦。
我是怎麼解決的呢？
方法比較笨！根據輸入的編碼陣列，我們要在指標陣列中根據不同字元的編碼和輸入的字串進行匹配，然後找到匹配的字元輸出。我就是先遍歷物件陣列，用每一個字元的編碼與所輸入的陣列前面的字元進行匹配，若匹配正確就將輸入的陣列中的剛匹配的字元全置為‘#’符號，然後再輸出物件陣列中存的對應字元，再從物件陣列頭開始和匹配陣列非‘#’元素再進行匹配

main函式

#include<iostream>
#include<stdlib.h>
#include<memory>
#include<list>
#include"hafuman.h"
using namespace std;
int main(){
	//智慧指標陣列
    array<shared_ptr<hafu>,SIZE>arr ;
    //初始化
    hafu::init(arr);
    //建立哈夫曼樹 
    hafu::process(arr);
    //獲取哈夫曼編碼
    hafu::makeCode(arr);
    //返回哈夫曼編碼
    hafu::request(arr);
    //翻譯編碼
    hafu::transform(arr);
}

標頭檔案

#ifndef _HAFU_H_
#define _HAFU_H_
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<memory>
#include<vector>
#include<list>
#include<string.h>
using namespace std;
//SIZE為字元個數
//MAXLINE為使用的字串長度
enum {SIZE = 11,MAXLINE = 100};
class data{
public:  
    int a ;
    char ch ;
    list<char>s;
};

class hafu:public data{
public:
    
    data da;
    int tag ;
    int l,p,r;
    hafu():tag(0){}
    ~hafu(){}
    //找當前陣列中無父節點的節點中字元頻率（權值）最大的節點
    static int findmax(int s,int &kl,array<shared_ptr<hafu>,SIZE>&ls);
    //找當前無父節點的節點中權值最小的兩個節點
    static void find(int s,int& kl,int &kr,array<shared_ptr<hafu>,SIZE>&ls);
    //初始化智慧指標陣列
    static void init(array<shared_ptr<hafu>,SIZE>&ls);
    //建立哈夫曼樹
    static void process(array<shared_ptr<hafu>,SIZE>&ls);
    //便利哈夫曼樹
    static void print(const array<shared_ptr<hafu>,SIZE>&ls);
    //編碼
    static void makeCode(array<shared_ptr<hafu>,SIZE>&ls);
    //逆置連結串列
    static void reverse(list<char>&s);
    //列印各個的編碼
    static void printCodes(array<shared_ptr<hafu>,SIZE>&ls);
    //輸入字元，返回相關編碼
    static void request(const array<shared_ptr<hafu>,SIZE>&ls);
    //列印各自父節點的編碼
    static void printlist( list<char>&s);
    //譯碼
    static void transform(const array<shared_ptr<hafu>,SIZE>&ls);
    static int search(list<char>&s ,char* arr,int i);
};

int hafu::search(list<char>&s,char *arr,int i){

        list<char>::iterator iter ;
        int k = 0 ;
        for(k = 0 ;k < strlen(arr);k++ ){
            if(arr[k]!='#')break ;
        }
        int m = k ;
        int count = 0 ;
        for(iter = s.begin();iter!=s.end();iter++){
                if(*iter == arr[k]){
                    count ++ ;
                    k++ ;
                }
                else{
                    return 0;
                }
        }
            int len = s.size();
            int kk = m;
            for(k = 0 ;k< len ;k++){
                kk = m+k;
                arr[kk] ='#';
            }
            return 1 ;
}

void hafu::transform(const array<shared_ptr<hafu>,SIZE>&ls){
    
    char s[MAXLINE];
    cin>>s;
    int i = 0,j ;
    int len = strlen(s);
    for(i =0 ;i< (SIZE+1)/2;i++){
        i = j ;
        if(s[strlen(s)-1]=='#'){
            break;

        }
        if(search(ls[i]->da.s,s,i)){
                cout<<ls[i]->da.ch<<"";
                j = 0 ;
            }
        else{
                j++ ;
            }
        }
        cout<<endl;
}

void hafu::printlist( list<char>&s){
     list<char>::iterator iter ;
     for(iter=s.begin();iter!=s.end() ;iter++){
                cout<<*iter<<"";
    }
}
void hafu::request(const array<shared_ptr<hafu>,SIZE>&ls){

    char arr[MAXLINE];
    cin>>arr ;
    int len = strlen(arr);
    int i ,j;
    int flag = 0 ;
    for(i = 0 ;i< len ;i++){
        for(j = 0 ;j<(SIZE+1)/2;j++){
            if(ls[j]->da.ch == arr[i]){
                printlist(ls[j]->da.s);
                flag =1 ;
            }
        }
        if(flag==0)return ;
    }
}

void hafu::printCodes(array<shared_ptr<hafu>,SIZE>&ls){
    
    int  i =  0;
    for(i = 0 ; i < (SIZE+1)/2 ;i++){
        list<char>::iterator iter ;
        cout<<ls[i]->da.ch<<":";
        for(iter = ls[i]->da.s.begin() ; iter!=ls[i]->da.s.end();iter++){
            cout<<*iter<<"";
        }
        cout<<endl ;
    }
    
}

void hafu:: reverse(list<char>&s){

    int i ;
    s.reverse();
}

void hafu::makeCode(array<shared_ptr<hafu>,SIZE>&ls){
    int  i  =  0 ;
    int j = 0;
    for(j = 0 ;j < (SIZE+1)/2;j++){
        int index = ls[j]->p;
         int k = j ;
         while(index){
          
            if(ls[index]->l == k){
               
                ls[j]->da.s.push_back('0');
            }
            if(ls[index]->r == k){
               
                ls[j]->da.s.push_back('1');
            }
            k = index ;
            index = ls[index]->p;
        }
        reverse(ls[j]->da.s);
    }
    printCodes(ls);
    
}

int hafu::findmax(int s,int &kl,array<shared_ptr<hafu>,SIZE>&ls){

        int i ,j;
        int temp ;
        kl = -1 ;
        int count = 0; 
        for(i = 0;i < s ;i++){
            if(kl< ls[i]->da.a && ls[i]->tag != 1){
                    kl = i;    
            }
            if(ls[i]->tag == 0)count++ ;
        }
}

void hafu::find(int s,int& kl,int &kr,array<shared_ptr<hafu>,SIZE>&ls){

    int i= 0, j = 0 ;
    int count ;
    count = findmax(s,kl,ls);
    if(count==1){
        kr = -1 ;
        return ;
    }
    
    int mins =ls[kl]->da.a+1;
    
    for(i = 0 ;i < 2 ;i++){
        int min = mins ;
        for(j = 0 ; j < s ; j++){
            
            if(i==0&&ls[j]->da.a < min&&ls[j]->tag == 0){

                   min = ls[j]->da.a ;
                   kl = j ;
            }

            if(i==1&&ls[j]->da.a < min&& ls[j]->tag==0){
                min = ls[j]->da.a ;
                kr = j;
            }
        }
        if(i == 0)ls[kl]->tag = 1 ;
        if(i == 1){
            ls[kr]->tag = 1 ;
            break ;
        }
    }
}
void hafu::print(const array<shared_ptr<hafu>,SIZE>&ls){
    int i = 0 ;
    for(i =0 ;i < SIZE ;i++){
        cout<<ls[i]->da.a<<"   "<<ls[i]->p<<"   "<<ls[i]->l<<"   "<<ls[i]->r<<endl;
    }
}

void hafu::process(array<shared_ptr<hafu>,SIZE>&ls){

    int  j = (SIZE+1)/2;
    int i ;
    int kl=-1,kr=-1 ;
    for(i =j ;i< SIZE;i++){
        find(i,kl,kr,ls);
        if(kr == -1)break ;
        ls[i]->da.a = ls[kr]->da.a + ls[kl]->da.a ;
        ls[i]->l = kl ;
        ls[i]->r = kr ;
        ls[kl]->p = i ;
        ls[kr]->p = i ;
    }
}

void hafu::init(array<shared_ptr<hafu>,SIZE>&ls){
    int j = 0 ;
    
    for(j = 0;j < SIZE;j++){
      shared_ptr<hafu>p(new hafu);
      if(j<6)cin>>p->da.a ;
      ls[j] = p ;
    }

    int i = 0;
    char ch;
    char arr[6] = {'A','B','C','D','E','F'};
        
    for(i = 0 ;i< (SIZE+1)/2;i++){
        ls[i]->da.ch=arr[i];
    }
    i = 0 ;
    while(1){
        if(i == SIZE){
            break ;
        }
        ls[i]->l = 0;
        ls[i]->r = 0;
        ls[i]->p = 0;
        if(i >= (SIZE+1)/2){
            ls[i]->da.ch = '\0';
            ls[i]->da.a = 0;
            i 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
哈夫曼編碼和譯碼&amp;&amp;c++重點知識的應用
     
  
  
  
 哈夫曼編碼和譯碼。將以前學的c++相關知識系統的用了一遍，反正是能想到啥，啥方便就用啥，但是說回來，也沒省多少事。反正比用c語言寫跟簡單一點。 先看題目原型吧！ 
 假設某通訊報文的字符集由A,B,C,D,E,F這6個字元組成，它們在報文中出現的頻度（頻度均為整數值）。
(1)構造一棵哈弗曼 

  
 

    

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

  
 

    

    
    
Java實現哈夫曼編碼和解碼
     
 
                
題目：將一個字串進行哈夫曼編碼；編碼過程中，會得到每個字元的編碼，通過已知的每個字元的編碼對之前的編碼進行解碼。
分析：
首先是哈夫曼編碼演算法，引用李澤年寫的《多媒體技術教程》中對哈夫曼編碼演算法的描述：

•Initialization: Put all symbols 

  
 

    

    
    
【視頻編解碼·學習筆記】7. 熵編碼算法：基礎知識 &amp; 哈夫曼編碼
     
 html   節點   表示   效率   article   tchar   vector   nod   code   一、熵編碼概念：
熵越大越混亂
信息學中的熵：

用於度量消息的平均信息量，和信息的不確定性
越是隨機的、前後不相關的信息，其熵越高

信源編碼定理：

說明了香農熵越信源符號概率之間的 

  
 

    

    
    
哈夫曼編碼(Huffman coding)的那些事,(編碼技術介紹和程序實現)
     
 信號   truct   依次   while   交換   需要   .text   示例   system   
 


前言
　　哈夫曼編碼(Huffman coding)是一種可變長的前綴碼。哈夫曼編碼使用的算法是David A. Huffman還是在MIT的學生時提出的，並且在1952年發表了名為《 

  
 

    

    
    
轉載：哈夫曼樹的構造和哈夫曼編碼（C++代碼實現）
     
 作者   pos   blank   字符   element   start   man   null   ==   作者：qiqifanqi 原文：http://blog.csdn.net/qiqifanqi/article/details/6038822

#include<stdio.h> 

  
 

    

    
    
哈夫曼（Huffman)樹和哈夫曼編碼
     
 選擇   其中   有一個   只有一個   bsp   nbsp   例子   left   style   一、哈夫曼（Huffman)樹和哈夫曼編碼
  1.哈夫曼樹（Huffman)又稱最優二叉樹，是一類帶權路徑長度最短的樹， 常用於信息檢測。
定義：
結點間的路徑長度:樹中一個結點到另一個結點之間分 

  
 

    

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

  
 

    

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

  
 

    

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





 哈夫曼樹和哈夫曼編碼 

  
 

    

    
    
資料結構課程設計-哈夫曼編碼譯碼
     
 
                
//********************************************
//程式功能:哈夫曼編碼及譯碼
//
//日期:2014年11月18
//
//********************************************
#incl 

  
 

    

    
    
資料結構之---C語言實現哈夫曼樹和編碼
     
 
                
//哈夫曼樹
//楊鑫
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
struct BTreeNode
{
    ElemType data;
    struct BTr 

  
 

    

    
    
建立哈夫曼樹並進行哈夫曼編碼與哈夫曼譯碼
     
 
							
							
							
圖例 
     
以上圖例解釋： 
 
c語言實現程式碼：




#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define N 100
#define 

  
 

    

    
    
南郵資料結構實驗二——哈夫曼編碼/譯碼系統
     
 
							
							
							實驗目標： 
                1、實現二叉樹的遍歷、計算節點等基本功能 
                2、編寫哈夫曼編碼/譯碼系統 
功能流程圖： 


實驗程式碼：



#include <iostream>
#include 

  
 

    

    
    
資料結構——哈夫曼編碼譯碼器
     
  
 
  
  
  
  題目5: 哈夫曼編/譯碼器 [問題描述] 利用哈夫曼編碼進行通訊可以大大提高通道利用率，縮簡訊息傳輸時間，降低傳輸成本。但是，這要求在傳送端通過一個編碼系統對待傳資料預先編碼，在接收端將傳來的資料進行譯碼（復原）。對於雙工通道（即可以雙向傳輸資訊的通道），每端都需要一個完整的編/ 

  
 

    

    
    
【資料結構基礎】哈夫曼編碼/譯碼課程設計
     
 
							
							
							#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 20   
typedef struct {
    char ch;
    int wei 

  
 

    

    
    
利用優先佇列編寫哈夫曼樹和編碼
     
 
								
								            
						
                
利用“有序連結串列”來實現優先佇列，連結串列元素按優先順序遞減。元素出列即出首元素，元素入列即將元素插入有序連結串列使其依然有序。本程式中，字元頻率小則優先順序高。

typedef int PQEl 

  
 

    

    
    
java 二叉樹（十三） 哈夫曼樹和哈夫曼編碼
     
 
                
一般可以按下面步驟構建：
1，將所有左，右子樹都為空的作為根節點。
2，在森林中選出兩棵根節點的權值最小的樹作為一棵新樹的左，右子樹，且置新樹的附加根節點的權值為其左，右子樹上根節點的權值之和。注意，左子樹的權值應小於右子樹的權值。
3，從森林中刪除這兩棵樹，同時把新樹加入 

  
 

    

    
    
二叉樹的基本操作及哈夫曼編碼譯碼的實現（實驗二）
     
 
							
							
							實驗目的： 
1.掌握二叉樹的二叉連結串列儲存表示及遍歷操作實現方法。




//完成二叉樹的建立，先序遍歷，中序遍歷，後續遍歷
#include<iostream>
#include<cstring>
using namespace  

  
 

    

    
    
Java 樹結構實際應用 二（哈夫曼樹和哈夫曼編碼）
     
  赫夫曼樹
1 基本介紹
1) 給定 n 個權值作為 n 個葉子結點，構造一棵二叉樹，若該樹的帶權路徑長度(wpl)達到最小，稱這樣的二叉樹為
最優二叉樹，也稱為哈夫曼樹(Huffman Tree), 還有的書翻譯為霍夫曼樹。
2) 赫夫曼樹是帶權路徑長度最短的樹，權值較大的結點離根較近