05-树9 Huffman Codes

整体思路：1.通过小根堆构建哈弗曼树，
2.通过哈弗曼树算出其WPL（最小编码长度）,并求出输入数据中的最小编码长度，两个相比较
3.判断输入数据中的哈夫曼编码前缀是否有重叠，判断时选择对于输入的数据构造一个新树，构造过程中对叶子结点标记，若第二次访问该结点说明前缀有重复。#include<iostream>
#include<string>
#define MaxSize 64
using namespace std;
typedef struct TreeNode {//树节点
int weight;
TreeNode *left = nullptr;
TreeNode *right = nullptr;
};
typedef struct HeapNode {//最小堆
TreeNode Data[MaxSize];
int size = 0;
};
typedef struct JNode {//用以表示输入数据中的节点
int Flag = 0;
JNode *left = nullptr;
JNode *right = nullptr;
};
HeapNode *CreateMinHeap(int N) {//创建最小堆
HeapNode *Heap = new HeapNode;
Heap->Data[0].weight = -1;
return Heap;
}
void InsertHeap(HeapNode *Heap, TreeNode *Item) {//向最小堆中插入节点
int i;
for (i = ++(Heap->size); Heap->Data[i / 2].weight > Item->weight; i /= 2) {//----平衡最小堆的模板，需要记住
//假设即将插入节点放在最后位置，比较其父节点与其大小关系，直至根结点
Heap->Data[i].weight = Heap->Data[i / 2].weight;
}
Heap->Data[i].weight = Item->weight;
}
TreeNode *DeleteHeap(HeapNode *Heap) {//取出最小堆中的值，并平衡最小堆
int Parent = 0, Child = 0;
TreeNode Temp;
TreeNode *MinItem = new TreeNode;
*MinItem = Heap->Data[1];//------
Temp = Heap->Data[Heap->size--];
for (Parent = 1; Parent * 2 <= Heap->size; Parent = Child) {//从根节点开始寻找最小值将其放到根结点位置
Child = Parent * 2;
if (Child != Heap->size && (Heap->Data[Child].weight) > Heap->Data[Child + 1].weight)
Child++;
if (Temp.weight < Heap->Data[Child].weight) {
break;
}
else {
Heap->Data[Parent].weight = Heap->Data[Child].weight;
}
}
Heap->Data[Parent] = Temp;
return MinItem;
}
HeapNode *ReadData(int N, HeapNode *H, int A[]) {//读取数据
char s = '\0';
int value;
for (int i = 0; i < N; i++) {
cin >> s >> value;
A[i] = value;
TreeNode *node = new TreeNode;
node->weight = value;
InsertHeap(H, node);
}
return H;
}
TreeNode *CreateHuffman(HeapNode *heap) {//构造哈弗曼树，从最小堆中取出两个最小值，然后加和其权值，将加和值插入堆中
TreeNode *T = nullptr;
int num = heap->size;
for (int i = 0; i < num - 1; i++) {
T = new TreeNode;
T->left = DeleteHeap(heap);
T->right = DeleteHeap(heap);
T->weight = T->left->weight + T->right->weight;
InsertHeap(heap, T);
}
T = DeleteHeap(heap);
return T;
}
int calculateWPL(TreeNode *T, int Depth) {//计算WPL，递归遍历所有结点
if (T->left == nullptr&&T->right == nullptr) {
return Depth*(T->weight);
}
else {
return (calculateWPL(T->left, Depth + 1) + calculateWPL(T->right, Depth + 1));
}
}
bool judge(string S, JNode *J) {//将输入的节点构造树，将每个节点设置一个岗哨，若岗哨被访问两次则说明编码前缀有重复
int i = 0;
for (; i < S.length(); i++) {
if (S[i] == '0') {
if (J->left == nullptr) {
JNode *j_1 = new JNode;
J->left = j_1;
}
else {
if (J->left->Flag == 1) {
return false;
}
}
J = J->left;
}
else {
if (J->right == nullptr) {
JNode *J_1 = new JNode;
J->right = J_1;
}
else {
if (J->right->Flag ==1) {
return false;
}
}
J = J->right;
}
}
J->Flag = 1;
if (J->left == nullptr&&J->right == nullptr) {
return true;
}
else {
return false;
}
}
int main()
{
int N = 0, n = 0;
cin >> N;
HeapNode *H = CreateMinHeap(N);
int Value[MaxSize] = {};
H = ReadData(N, H, Value);
TreeNode *T = CreateHuffman(H);
int CodeLen = calculateWPL(T, 0);
cin >> n;
string temp;
char c = '\0';
bool result = false;
for (int i = 0; i < n; i++) {
int count = 0, flag = 0;
JNode *J = new JNode;
for (int k = 0; k < N; k++) {
cin >> c >> temp;
count += temp.length()*Value[k];

if (!flag) {
result = judge(temp, J);
if (!result) {
flag = 1;
}
}
}
delete J;
if (result && (count == CodeLen)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
return 0;
}