Huffman

最新推荐文章于 2024-01-22 13:01:38 发布

转载最新推荐文章于 2024-01-22 13:01:38 发布 · 278 阅读

Description

1、问题描述

给定n个权值，根据这些权值构造huffman树，并进行huffman编码，以使得到的平均码长最短的编码。

请正确构造huffman类，将建树和编码函数作为成员函数。请编写主函数模仿编码过程确保类及函数是否能正确工作。

2、算法

1．建huffman树算法

(1)、根据给定的n个权值(w1, w2, …, wn)构成n棵二叉树的集合F={T1, T2, …, Tn}，其中每棵二叉树Ti中只有一个带树为Ti的根结点

(2)、在F中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树，且置其根结点的权值为其左右子树权值之和

(3)、在F中删除这两棵树，同时将新得到的二叉树加入F中

(4)、重复2, 3，直到F只含一棵树为止

2．huffman编码算法

⑴、从huffman树的每一个叶子结点开始

⑵、依次沿结点到根的路径，判断该结点是父亲结点的左孩子还是右孩子，如果是左孩子则得到编码0，否则得到编码1，先得到的编码放在后面

⑶、直到到达根结点，编码序列即为该结点的编码的

⑷、对所有的叶子结点重复2，3得到编码。

Input

⑴、第一行：测试次数。

⑵、每个样本分2行：

第一行：数字m表示权值数目；

第二行：m个权值。

Output

每个测试样本按照权值输入先后顺序依次输出权值及编码，每个权值与编码用冒号分隔，且单独成行

Sample Input

Sample Output

//============================= 
#include <iostream> 
#include <stdlib.h> 
#include <string.h> 
//#include <stdio.h> 
using namespace std; 
//============================= 
const int MaxValue = 1000; 
const int MaxN = 10; 
//============================= 
struct HuffNode 
{ 
    int weight; 
    int flag; 
    int parent; 
    int leftChild; 
    int rightChild; 
}; 
//============================= 
struct Code 
{ 
    char bit[MaxN]; 
    int start; 
    int weight; 
}; 
//============================= 
class HuffMan 
{ 
private: 
    int length; 
    int *weight; 
    HuffNode *hufftree; 
    Code *huffcode; 
    void makeHufftree(int weight[],int n,HuffNode HuffTree[]); 
    void HuffmanCode(HuffNode HuffTree[],int n,Code HuffCode[]); 
public: 
    HuffMan(){}; 
    HuffMan(int n); 
    HuffMan(int n,int wt[]); 
    void Huffcoding(); 
    void showHuff(); 
}; 
//============================= 
HuffMan::HuffMan(int n) 
{ 
    length = n; 
    weight = (int *)malloc(sizeof(int)*(n+1)); 
    hufftree = (HuffNode*)malloc(sizeof(HuffNode)*2*n); 
    huffcode = (Code *)malloc(sizeof(Code)*(n+1)); 
} 
//============================= 
HuffMan::HuffMan(int n,int wt[]) 
{ 
    int i; 
    length = n; 
    weight = (int *)malloc(sizeof(int)*n); 
    for(i = 0;i<n;i++) 
        weight[i] = wt[i]; 
    hufftree = (HuffNode*)malloc(sizeof(HuffNode)*(2*n-1)); 
    huffcode = (Code *)malloc(sizeof(Code)*n); 
    makeHufftree(weight,n,hufftree); 
} 
//============================= 
void HuffMan::Huffcoding() 
{ 
    HuffmanCode(hufftree,length,huffcode); 
} 
//============================= 
void HuffMan::showHuff() 
{ 
    int i; 
    for(i=0;i<length;i++) 
        cout<<huffcode[i].weight<<"："<<huffcode[i].bit+huffcode[i].start<<endl; 
} 
//============================= 
void HuffMan::makeHufftree(int weight[],int n,HuffNode HuffTree[]) 
{ 
    int i,j,m1,m2,x1,x2; 
    for(i=0;i<2*n-1;i++) 
    { 
        if(i<n) 
            HuffTree[i].weight = weight[i]; 
        else
            HuffTree[i].weight = 0; 
        HuffTree[i].parent = -1; 
        HuffTree[i].flag = 0; 
        HuffTree[i].leftChild = -1; 
        HuffTree[i].rightChild = -1; 
    } 
    for(i=0;i<n-1;i++) 
    { 
        m1 = m2 =MaxValue; 
        x1 = x2 = 0; 
        for(j = 0;j < n+i;j++) 
        { 
            if(HuffTree[j].weight < m1 && HuffTree[j].flag == 0) 
            { 
                m2 = m1; 
                x2 = x1; 
                m1 = HuffTree[j].weight; 
                x1 = j; 
            } 
            else if(HuffTree[j].weight<m2 && HuffTree[j].flag == 0)
            { 
                m2 = HuffTree[j].weight; 
                x2 = j;  
            } 
        } 
        HuffTree[x1].parent = n+i; 
        HuffTree[x2].parent = n+i; 
        HuffTree[x1].flag = 1; 
        HuffTree[x2].flag = 1; 
        HuffTree[n+i].weight = HuffTree[x1].weight + HuffTree[x2].weight; 
        HuffTree[n+i].leftChild = x1; 
        HuffTree[n+i].rightChild = x2; 
    } 
  
  
} 
//============================= 
void HuffMan::HuffmanCode(HuffNode HuffTree[],int n,Code HuffCode[]) 
{ 
    Code *cd = new Code; 
    int i,j,child,parent; 
    for(i = 0;i<n;i++) 
    { 
        cd->bit[n] ='\0'; 
        cd->start = n-1; 
        cd->weight = HuffTree[i].weight; 
        child = i; 
        parent = HuffTree[child].parent; 
        while(parent != -1) 
        { 
            if(HuffTree[parent].leftChild == child) 
                cd->bit[cd->start] = '0'; 
            else
                cd->bit[cd->start] = '1'; 
            cd->start--; 
            child = parent; 
            parent = HuffTree[child].parent; 
        } 
        for(j= cd->start + 1;j<=n;j++)
            HuffCode[i].bit[j] = cd->bit[j]; 
        HuffCode[i].start = cd->start + 1; 
        HuffCode[i].weight = cd->weight; 
    } 
} 
//============================= 
int main() 
{ 
    int m,n,i,j; 
    int wt[MaxN]; 
    cin>>m; 
    for(i = 0;i<m;i++) 
    { 
        cin>>n; 
        for(j = 0;j <n;j++) 
            cin>>wt[j]; 
        HuffMan myhuff(n,wt); 
        myhuff.Huffcoding(); 
        myhuff.showHuff(); 
    } 
    return 0; 
} 
//============================= 
/************************************************************** 
    Problem: 1245 
    User: 2011150144 
    Language: C++ 
    Result: Accepted 
    Time:0 ms 
    Memory:1268 kb 
****************************************************************/