第1关：基于哈夫曼树的数据压缩算法-头歌-北京林大

第1关：基于哈夫曼树的数据压缩算法-头歌-北京林大

任务描述

输入一串字符串，根据给定的字符串中字符出现的频率建立相应哈夫曼树，构造哈夫曼编码表，在此基础上可以对待压缩文件进行压缩（即编码），同时可以对压缩后的二进制编码文件进行解压（即译码）。

编程要求

输入

多组数据，每组数据一行，为一个字符串（只考虑26个小写字母即可）。当输入字符串为“0”时，输入结束。

输出

每组数据输出2n+4行（n为输入串中字符类别的个数）。第一行为统计出来的字符出现频率（只输出存在的字符，格式为：字符：频度），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第二行至第2n行为哈夫曼树的存储结构的终态（形如教材139页表5.2（b），一行当中的数据用空格分隔）。第2n+2行为每个字符的哈夫曼编码（只输出存在的字符，格式为：字符：编码），每两组字符之间用一个空格分隔，字符按照ASCII码从小到大的顺序排列。第2n+3行为编码后的字符串，第2n+4行为解码后的字符串（与输入的字符串相同）。

测试说明

平台会对你编写的代码进行测试：

测试输入：

aaaaaaabbbbbccdddd

aabccc

0

预期输出：

a:7 b:5 c:2 d:4

1 7 7 0 0

2 5 6 0 0

3 2 5 0 0

4 4 5 0 0

5 6 6 3 4

6 11 7 2 5

7 18 0 1 6

a:0 b:10 c:110 d:111

00000001010101010110110111111111111

aaaaaaabbbbbccdddd

a:2 b:1 c:3

1 2 4 0 0

2 1 4 0 0

3 3 5 0 0

4 3 5 2 1

5 6 0 3 4

a:11 b:10 c:0

111110000

aabccc

参考答案

#include<iostream>
#include<string.h>
#define MAXSIZE 100
using namespace std;
typedef struct
{//哈夫曼树结点的形式
	int weight;               //结点的权值
	int parent,lchild,rchild;  //结点的双亲、左孩子、右孩子的下标
}HTNode,*HuffmanTree;       //动态分配数组存储哈夫曼树
typedef char **HuffmanCode;   //定义编码表类型
int Search(char a[],char ch)
{//查找数组中字符ch所在的位置，返回数组下标，否则返回-1
	for(int i=0;a[i]!='\0';i++)
	{
		if(a[i]==ch) return i;
	}
	return -1;
}
void Sort(char a[],int b[],int len)
{//按ASCII码冒泡排序
/**************begin************/
for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (strcmp(&a[j], &a[j + 1]) > 0) { // 如果前面的字符比后面的字符大
                char temp = a[j];
                int t = b[j];
                a[j] = a[j + 1];
                a[j + 1] = temp; //把前面的字符和后面的字符交换
                b[j] = b[j+1];
                b[j+1] = temp;//b同上
            }
        }
    }
    /**************end************/
}
void Select_min(HuffmanTree HT,int n,int &s1,int &s2)
{// 在HT[k](1≤k≤i-1）中选择两个其双亲域为0且权值最小的结点，并返回它们在HT中的序号s1和s2
/**************begin************/
int MIN1=0x3f3f3f3f,MIN2=0x3f3f3f3f;//MIN1最小值，MIN2次小值  0x3f3f3f3f表示为数值初始化成正无穷大
    for(int i=1;i<=n;i++){
        if(!HT[i].parent&&HT[i].weight<MIN1){
            //小于最小值 把最小值赋值给次小值 并把最小值的下标赋值给次小值的下标
            MIN2=MIN1;
            s2=s1;
            MIN1=HT[i].weight;
            s1=i;
        }
        else if(!HT[i].parent&&HT[i].weight<MIN2){
            //小于次小值
            MIN2=HT[i].weight;
            s2=i;
        }
    }
    /**************end************/
}
int m;
void CreateHuffmanTree(HuffmanTree &HT,int n,int b[])
{//构造哈夫曼树HT
/**************begin************/
	if(n<=1) return;
    m = 2*n-1; //n个权值共有2n-1个节点
    HT = new HTNode[m+1];//从下标为1开始，所以分配m+1个单元
    for(int i=1;i<=m;i++)
    {
        //初始化为0 防止存储之前的旧数据
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    for(int i=0;i<n;i++)
    {
        HT[i+1].weight = b[i];
    }
    int s1,s2;
    for(int i=n+1 ; i<=m; i++)
    {
        Select_min(HT,i-1,s1,s2);
        HT[s1].parent = i;HT[s2].parent = i;//双亲由0改为i
        HT[i].lchild = s1;
        HT[i].rchild = s2; //s1和s2分别作为i的左右孩子
        HT[i].weight = HT[s1].weight + HT[s2].weight;//i的权值为左右孩子权值之和
    }
    /**************end************/
}
void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)
{//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
/**************begin************/
//课本136页
	HC = new char*[n+1];//分配存储n个字符编码的编码表空间
    char *cd = new char[n];//分配临时存放每个字符编码的动态数组空间
    cd[n-1]='\0';//编码结束符
    for (int i=1;i<=n;i++)
    {
        int start=n-1;//start开始时指向最后，即编码结束符位置
        int c=i;
        int f=HT[i].parent;//f指向节点c的双亲结点
        while(f!=0)
        {
            start--;
            if(HT[f].lchild == c) cd[start]='0';//结点c是f的左孩子，则生成代码0
            else cd[start] ='1';//结点c是f的右孩子，则生成代码1
            c = f;
            f = HT[f].parent;//继续向上回溯
        }
        HC[i]=new char[n-start];//为第i个字符的编码分配空间
        strcpy(HC[i],&cd[start]);//将求得的编码从临时空间cd复制到HC的当前行中

    }
    delete cd;//释放临时空间
    /**************end************/
}
void CharFrequency(char ch[],char a[],int b[],int &j)
{//统计词频
/**************begin************/
a[0] = ch[0];//先存储第一个
j = 1;//j初始化为1
for(int i=0;i<strlen(ch);i++)
{
    int index = Search(a,ch[i]);
    if(index > -1)
    {  //在其中
        b[index]++;
    }else
    {  //不在其中
        b[strlen(a)] = 1;
        a[strlen(a)] = ch[i];
        j++;
    }
}
    /**************end************/
}
void PrintHT(HuffmanTree HT)
{//输出哈夫曼树的存储结构的终态
/**************begin************/
//m在56行已经定义
for (int i=1;i<=m;i++)
{
    cout << i << " " << HT[i].weight << " " << HT[i].parent << " " << HT[i].lchild << " " << HT[i].rchild << endl;
}
    /**************end************/
}
void PrintHC(HuffmanCode HC,char a[],int j)
{//输出每个字符的哈夫曼编码
/**************begin************/
for(int i=1 ; i<=j; i++){
    if(i == j)
    {
        cout<<a[i-1]<<":"<<HC[i]<<endl;//最后一个直接换行
    }else{
        cout<<a[i-1]<<":"<<HC[i]<<" ";
    }
}
    /**************end************/
}
int main()
{
	char ch[MAXSIZE];
	int i,j;
	while(cin>>ch)
	{
		if(ch[0]=='0') break;
		HuffmanTree HT;
		char a[MAXSIZE]={'\0'};
		int b[MAXSIZE]={0};
		j=0;      //j统计不同字符的数量
		CharFrequency(ch,a,b,j);   //统计词频
		Sort(a,b,j);     //按ASCII码冒泡排序
		for(i=0;a[i]!='\0';i++)   //输出统计出来的字符和出现频率
		{
			if(a[i+1]!='\0')
				cout<<a[i]<<":"<<b[i]<<" ";
			else
				cout<<a[i]<<":"<<b[i]<<endl;
		}
		//构造哈夫曼树
		CreateHuffmanTree(HT,i,b);    //构造哈夫曼树HT
		PrintHT(HT);      //输出哈夫曼树的存储结构的终态
		//哈夫曼编码
		HuffmanCode HC;    //编码表HC
		CreateHuffmanCode(HT,HC,j);
		PrintHC(HC,a,j);    //输出每个字符的哈夫曼编码
		int k;
		for(i=0;ch[i]!='\0';i++)    //输出编码后的字符串
		{
			for(k=0;k<j;k++)
			{
				if(ch[i]==a[k])
					cout<<HC[k+1];
			}
		}
		cout<<endl;
		cout<<ch<<endl;//输出解码后的字符串（与输入的字符串相同）
	}
	return 0;
}

来源：北京林业大学OJ