pta 编程题14 Huffman Codes

其它pta数据结构编程题请参见：pta

题目

题目给出一组字母和每个字母的频数，因为哈夫曼编码不唯一，然后给出几组编码，因为哈夫曼编码不唯一，所以让你判断这些编码是否符合是哈夫曼编码的一种。

解题思路：

1、构造哈夫曼树，并求出总代价COST，即各个字母的频数乘以编码长度的和。

2、对于题目给出的每一组编码，判断是否符合哈夫曼编码，即这组编码是否为前缀码，同时代价cost是否等于计算出的哈夫曼树的代价COST。

判断一组编码是否为前缀码的方法:

将这些编码逐个的添加到哈夫曼树中，对于每一个编码字符串，字符串中的每一个字符也逐个扫描，如果是0则向左构造树，1则向右构造树。如果已扫描到某节点为叶子节点但字符串还未结束，或者字符串已扫描结束但还当前节点非空，那么就不是前缀码。

需要注意的点：

最小堆数组中的元素类型ElementType为HuffmanTree型。

#include <iostream>
#include <string>
#include <map>
using namespace std;

/*----------哈夫曼树定义---------*/
typedef struct HuffmanNode *HuffmanTree;
struct HuffmanNode
{
    int weight;
    HuffmanTree left, right;
};
/*----------最小堆定义-----------*/
#define minData -1;
typedef HuffmanTree ElementType;
typedef struct HeapNode* minHeap;
struct HeapNode
{
    ElementType *data;
    int size;
};
/*----------最小堆相关操作--------*/
minHeap buildHeap(int N);
void percDown(minHeap H, int p);
void insert(minHeap H, HuffmanTree x);
HuffmanTree deleteMin(minHeap H);
/*----------哈夫曼树相关操作------*/
HuffmanTree huffman(int N);
HuffmanTree initHuffmanNode(int weight);
bool cmp(HuffmanTree a, HuffmanTree b);
void getLength(HuffmanTree T, int& total, int length);
/*----------其它操作--------------*/
bool valid(int N, int total);
HuffmanTree insertHuffman(HuffmanTree T, string s, int n, bool& judge);
map<string, int> mapp;
/*--------------------------------*/

int main()
{
    int N, M, i;
    cin >> N;
    HuffmanTree T = huffman(N); //构造哈夫曼树
    int total = 0; //总哈夫曼编码长度
    getLength(T, total, 0);
    cin >> M;
    for (i = 0; i < M; i++)
    {
        if (valid(N, total)) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
    return 0;
}

HuffmanTree initHuffmanNode(int weight)
{
    HuffmanTree T = new HuffmanNode;
    T->weight = weight;
    T->left = T->right = NULL;
    return T;
}

minHeap buildHeap(int N)
{
    minHeap H = new HeapNode;
    H->data = new ElementType[N + 1];
    H->size = 0;
    H->data[0] = initHuffmanNode(-1);//哨兵

    string c;
    int i, t;
    for (i = 1; i <= N; i++)
    {
        cin >> c >> t;
        mapp[c] = t;
        H->data[i] = initHuffmanNode(t);
    }
    H->size = N;

    /* 调整堆中的元素 */
    for (i = H->size / 2; i > 0; i--)
        percDown(H, i);
    return H;
}

void percDown(minHeap H, int p)
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最小堆 */
    int parent, child;
    ElementType X = H->data[p];
    for (parent = p; parent * 2 <= H->size; parent = child)
    {
        child = parent * 2;
        if (child != H->size && cmp(H->data[child], H->data[child + 1]))
            child++;
        if (!cmp(X, H->data[child])) break;
        else
            H->data[parent] = H->data[child];
    }
    H->data[parent] = X;
}

void insert(minHeap H, HuffmanTree x)
{
    int i;
    for (i = ++H->size; cmp(H->data[i / 2], x); i /= 2)
        H->data[i] = H->data[i / 2];
    H->data[i] = x;
}

HuffmanTree deleteMin(minHeap H)
{
    HuffmanTree minItem = H->data[1];
    ElementType x = H->data[H->size--];
    int parent, child;
    for (parent = 1; parent * 2 <= H->size; parent = child)
    {
        child = parent * 2;
        if (child != H->size && cmp(H->data[child], H->data[child + 1]))
            child++; //将两个子节点中较小的一个和x比较
        if (!cmp(x, H->data[child])) break;
        else
            H->data[parent] = H->data[child];
    }
    H->data[parent] = x;
    return minItem;
}

HuffmanTree huffman(int N)
{
    HuffmanTree T;
    minHeap H = buildHeap(N);

    while (H->size > 1)
    {
        T = new HuffmanNode;
        T->left = deleteMin(H);
        T->right = deleteMin(H);
        T->weight = T->left->weight + T->right->weight;
        insert(H, T);
    }
    T = deleteMin(H);
    return T;
}

bool cmp(HuffmanTree a, HuffmanTree b)
{
    return a->weight > b->weight;
}

void getLength(HuffmanTree T, int& total, int length)
{
    if (!T) return;
    if (!T->left && !T->right) //叶子节点
        total += length * T->weight;
    getLength(T->left, total, length + 1);
    getLength(T->right, total, length + 1);
}

bool valid(int N, int total)
{
    string c, s;
    bool isValid = true;
    int i, sum = 0;
    HuffmanTree T = initHuffmanNode(0);
    for (i = 0; i < N; i++)
    {
        cin >> c >> s;
        sum += s.size() * mapp[c];
        if (!isValid) continue;
        if (s[0] == '0')
            T->left = insertHuffman(T->left, s, 0, isValid);
        else
            T->right = insertHuffman(T->right, s, 0, isValid);
    }
    if (!isValid || sum != total) return false;
    else return true;
}

HuffmanTree insertHuffman(HuffmanTree T, string s, int n, bool& judge)
{
    if (!T)
        T = initHuffmanNode(0);
    else
    {

        if (n + 1 == s.size()) judge = false;//当前节点非空且为字符串最后一个字符
        else if (!T->left && !T->right)//当前节点为叶子节点且字符串还未结束
            judge = false;
    }
    if (n + 1 < s.size())
    {
        if (s[n + 1] == '0')
            T->left = insertHuffman(T->left, s, n + 1, judge);
        else
            T->right = insertHuffman(T->right, s, n + 1, judge);
    }
    return T;
}