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;
}