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 = ; //总哈夫曼编码长度
     getLength(T, total, );
     cin >> M;
     for (i = ; i < M; i++)
     {
         if (valid(N, total)) cout << "Yes" << endl;
         else cout << "No" << endl;
     }
     return ;
 }

 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 + ];
     H->size = ;
     H->data[] = initHuffmanNode(-);//哨兵

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

     /* 调整堆中的元素 */
     for (i = H->size / ; i > ; 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 *  <= H->size; parent = child)
     {
         child = parent * ;
         if (child != H->size && cmp(H->data[child], H->data[child + ]))
             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 / ], x); i /= )
         H->data[i] = H->data[i / ];
     H->data[i] = x;
 }

 HuffmanTree deleteMin(minHeap H)
 {
     HuffmanTree minItem = H->data[];
     ElementType x = H->data[H->size--];
     int parent, child;
     for (parent = ; parent *  <= H->size; parent = child)
     {
         child = parent * ;
         if (child != H->size && cmp(H->data[child], H->data[child + ]))
             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 > )
     {
         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 + );
     getLength(T->right, total, length + );
 }

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

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

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