7-1 哈夫曼编码（数组实现方法）

7-1 哈夫曼编码（数组实现方法）

给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 ‘a’、‘x’、‘u’、‘z’ 的出现频率对应为 4、2、1、1。我们可以设计编码 {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}，也可以用另一套 {‘a’=1, ‘x’=01, ‘u’=001, ‘z’=000}，还可以用 {‘a’=0, ‘x’=11, ‘u’=100, ‘z’=101}，三套编码都可以把原文压缩到 14 个字节。但是 {‘a’=0, ‘x’=01, ‘u’=011, ‘z’=001} 就不是哈夫曼编码，因为用这套编码压缩得到 00001011001001 后，解码的结果不唯一，“aaaxuaxz” 和 “aazuaxax” 都可以对应解码的结果。本题就请你判断任一套编码是否哈夫曼编码。

输入格式：

在这里插入代码片首先第一行给出一个正整数 N（2≤N≤63），随后第二行给出 N 个不重复的字符及其出现频率，格式如下：

c[1] f[1] c[2] f[2] ... c[N] f[N]

其中c[i]是集合{‘0’ - ‘9’, ‘a’ - ‘z’, ‘A’ - ‘Z’, ‘_’}中的字符；f[i]是c[i]的出现频率，为不超过 1000 的整数。再下一行给出一个正整数 M（≤1000），随后是 M 套待检的编码。每套编码占 N 行，格式为：

c[i] code[i]

其中c[i]是第i个字符；code[i]是不超过63个’0’和’1’的非空字符串。

输出格式：

对每套待检编码，如果是正确的哈夫曼编码，就在一行中输出"Yes"，否则输出"No"。

注意：最优编码并不一定通过哈夫曼算法得到。任何能压缩到最优长度的前缀编码都应被判为正确。

解题思路

检测哈夫曼编码是否正确，关键在于两点

第一，编码长度是否最短（是否等于哈夫曼编码的总长度）
第二，编码是否为前缀码

• 首先我们可以根据输入求出哈夫曼编码的编码总长度（最短编码长度）

• 得到这个总长度后，再计算出每套待检测的编码的编码总长度，与哈夫曼编码的编码总长度对比

• 如果不相等，那么此套编码就不是哈夫曼编码

• 如果相等，接着判断是否为前缀码阶段，如果不是，那么此套编码也不是哈夫曼编码。

也就是说，如果待检测编码的编码总长度与哈夫曼编码的编码总长度相等，且它是前缀码，那么它就是哈夫曼编码。

注：

在求哈夫曼编码的编码总长度时，我构建一个二维数组c[n*2-1][2]，用来模拟树的节点，其中c[#][0]用来存放这个节点的权值，c[#][1]用来存放该节点的父节点在这个数组上的位序，即【父节点位序】。

• 每次挑选出数组中【父节点位序】为0，且权值最小的那个节点，
• 把下一个未使用的节点（权值，【父节点位序】都为0的节点）的位序作为该节点的【父节点位序】，
• 这样，这个未使用的节点就成了该节点的父节点，
• 并把该节点的权值加到它的父节点的权值之上。

每一次循环中挑选两次。

举个例子

如果我输入的是
4
A 1 B 2 C 3 D 4
的话，那么这个数组的构建完成之后就是这个样子
由上到下位序0～6

c[0]	c[1]
1	4
2	4
3	5
4	6
3	5
6	6
10	0

输入样例：

A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11

输出样例：

Yes
Yes
No
No

实现代码如下

//  main.cpp
//  哈夫曼编码
//
//  Created by 梦有蝶 on 2019/11/15.
//  Copyright © 2019 梦有蝶. All rights reserved.
//
#include <iostream>
#include <string.h>
using namespace std;

int main() {
    int n,m;//n为节点个数，m为待检测编码的套数
    cin>>n;
    char NodeName[n];//存放节点名称
    unsigned int c[n*2-1][2];
    //定义无符号数int型二维数组，数组长度为哈夫曼树的节点个数，其中c[*][0]存放的是该节点的权值，c[*][1]为该节点的【父节点的位序】
    unsigned int cl[n];//定义无符号数int型数组，用来存放各个节点到根节点的路径长度
    
    //数组初始化
    for (int i=0;i<n; i++)
    {
        cin>>NodeName[i];
        cin>>c[i][0];
        c[i][1]=0;
        cl[i]=0;
    }
    for(int i=0;i<n-1;i++)
    {
        c[n+i][0]=0;
        c[n+i][1]=0;
    }
    
    //数组构建
    for (int i=0; i<n-1; i++) {
        int min=0;
        while (c[min][1]!=0) {//找到第一个c[j][1]=0的，即找到第一个没有父节点的节点
            min++;
        }
        for(int j=0;j<n+i;j++)//在c[j][1]=0（没有父节点的节点）之中找到权值最小的
        {
            if(c[j][1]==0)
            {
                if(c[j][0]<c[min][0])
                    min=j;
            }
        }
        c[min][1]=n+i;//此时找到的节点，把数组中第一个未使用（但是已经被赋值为0，0）的节点的位序作为它的【父节点的位序】
        c[n+i][0]=c[min][0];//父节点的权值等于子节点的权值之和
        
        min=0;
        while (c[min][1]!=0) {
            min++;
        }
        for(int j=0;j<n+i;j++)//再次在没有父节点的节点之中找到权值最小的
        {
            if(c[j][1]==0)
            {
                if(c[j][0]<c[min][0])
                    min=j;
            }
        }
        c[min][1]=n+i;//此时找到的节点，把数组中第一个未使用（但是已经被赋值为0，0）的节点作为它的【父节点的位序】
        c[n+i][0]+=c[min][0];//父节点的权值等于子节点的权值之和
    }
    
    //计算各个节点的路径长度
    for(int i=0;i<n;i++)
    {
        //数组构建完成后，只有最后一个节点没有父节点
        while (c[i][1]!=0) {//最后一个父节点的【父节点的为序】为0
            c[i][1]=c[c[i][1]][1];//子节点向上寻父节点，将当前节点的父节点的【父节点的位序】作为当前节点的【父节点的位序】
            cl[i]++;//路径长度加一
        }
    }
    //计算总路径长度
    int Length=0;
    for(int i=0;i<n;i++)
        Length+=c[i][0]*cl[i];
    
    cin>>m;//读取待检测的编码的套数
    int p[m];//用来存取各套编码是否为哈夫曼编码，是则为1，否则为0
    for(int i=0;i<m;i++)//为p[m]赋初始值为1
        p[i]=1;
    char cn[m][n];//建立字符数组存储节点名称
    string hc[m][n];//建立字符串数组存储待检测的哈夫曼编码
    for(int i=0;i<m;i++)//读取节点名称以及编码
        for(int j=0;j<n;j++)
            {
                cin>>cn[i][j];
                cin>>hc[i][j];
            }
    
    //检测哈夫曼编码
    for (int i=0; i<m; i++) {
        int l=0;
        for (int j=0; j<n; j++) {
            l+=c[j][0]*hc[i][j].length();
        }
        if(l!=Length)//如果编码总长度与哈夫曼编码总长度不一致
        {
            p[i]=0;
            continue;
        }
        else
        {
            for(int j=0;j<n;j++)
                for(int k=0;k<n;k++)
                {
                    if(k!=j)
                    {
                        int q;
                        q = hc[i][j].find(hc[i][k]);
                        //在hc[i][j]这个字符串中查找hc[i][k]，并把找到的位置返回给q
                        if(q==0)
                        //如果找到的是第一个位置，说明编码不是前缀码，不是哈夫曼编码
                        p[i]=0;
                    }
                }
        }
    }
   
    //输出结果
    for(int i=0;i<m;i++)
    {
        if(p[i]==1)
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
    }
    
    return 0;
}