数据结构树 —— 编程作业 11 ：Huffman Codes

Posted 2021-06-15 大彤小忆

  题目描述： 1953年，David A. Huffman发表了他的论文“A Method for the Construction of Minimum-Redundancy Codes”，因此他的名字被印在了计算机科学史上。作为一个期末考试题目是关于哈夫曼编码的教授，我遇到了一个大问题：哈夫曼编码不是唯一的。例如，给定一个字符串“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}，两者都将字符串压缩为14位。另一组代码可以给出为{‘a’= 0，‘x’= 11，‘u’= 100，‘z’= 101}，但由于“aaaxuaxz” 和 “aazuaxax”可以从代码00001011001001解码，{‘a’=0, ‘x’=01, ‘u’=011, ‘z’=001} 是不正确的。学生正在提交各种代码，我需要一个计算机程序来帮助我确定哪些是正确的，哪些不是。

  输入格式： 每个输入文件包含一个测试用例。
        对于每种情况，第一行给出一个整数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”。
        注：最优解不一定由哈夫曼算法生成。任何具有最佳代码长度的前缀代码都被认为是正确的。

  输入样例：

7
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

  代码实现：

#include<iostream>
using namespace std;
#include<string>
#include<map>
#define HeapCapacity 64
#define MinData 0

typedef struct TreeNode *HuffmanTree;
struct TreeNode {   // 哈夫曼树 
	int weight;  // 频率
	HuffmanTree left;
	HuffmanTree right;
};

typedef struct Heap *MinHeap;
struct Heap {   // 堆 
	HuffmanTree *data;  // 存哈夫曼树 
	int size; // 堆的当前大小 
};

MinHeap createHeap();   // 建堆 
HuffmanTree createHuffman();  // 建哈夫曼树 
void sortHeap(MinHeap H, int i); // 调整子最小堆 
void adjust(MinHeap H);  // 调整堆 
MinHeap InitHeap(int n); // 初始化堆 
HuffmanTree Delete(MinHeap H); // 堆的删除 
void Insert(MinHeap H, HuffmanTree Huff); // 堆的插入 
HuffmanTree Huffman(MinHeap H);  // 哈夫曼树的构造 
int WPL(HuffmanTree Huff, int depth); // 计算 HuffmanTree 的编码长度 

map<char, int> mappp;  // 保存字符到频率的映射关系 

// 建堆 
MinHeap createHeap() 
{
	MinHeap H;
	H = (MinHeap)malloc(sizeof(struct Heap));
	H->data = (HuffmanTree *)malloc(sizeof(struct TreeNode) * HeapCapacity);
	H->size = 0;
	// 设置哨兵
	HuffmanTree Huff = createHuffman();
	H->data[0] = Huff;
	return H;
}

// 建哈夫曼树 
HuffmanTree createHuffman() 
{
	HuffmanTree Huff;
	Huff = (HuffmanTree)malloc(sizeof(struct TreeNode));
	Huff->weight = MinData;   // 初始化成频率最小 
	Huff->left = NULL;
	Huff->right = NULL;
	return Huff;
}

// 调整子最小堆 
void sortHeap(MinHeap H, int i) 
{
	int parent, child;
	HuffmanTree Huff = H->data[i]; // 拿到当前根结点的哈夫曼树
	for (parent = i; parent * 2 <= H->size; parent = child) 
	{
		// 左右儿子中挑小的 
		child = parent * 2;
		if ((child != H->size) && (H->data[child + 1]->weight < H->data[child]->weight))
			child++;
		// 没有更小的了，结束循环 
		if (Huff->weight <= H->data[child]->weight)
			break;
		// 否则把儿子结点拿上来
		H->data[parent] = H->data[child];
	}
	H->data[parent] = Huff;
}


// 调整堆 
void adjust(MinHeap H) 
{
	// 从第一个有孩子结点的结点开始调整 
	for (int i = H->size / 2; i > 0; i--)
		sortHeap(H, i);
}

// 初始化堆 
MinHeap InitHeap(int n) 
{
	MinHeap H = createHeap();
	HuffmanTree Huff;
	char c;  // 临时保存字符 
	int f;  //  临时保存频率 
	for (int i = 0; i < n; i++) 
	{
		getchar();
		cin >> c >> f;
		mappp.insert(pair<char, int>(c, f));  // 把字符和频率的映射关系存进map 
		Huff = createHuffman();
		Huff->weight = f;
		H->data[++H->size] = Huff;
	}
	// 调整最小堆 
	adjust(H);
	return H;
}

// 堆的删除 
HuffmanTree Delete(MinHeap H) 
{
	int parent, child;
	HuffmanTree T = H->data[1]; // 拿到根结点的哈夫曼树 
	HuffmanTree Huff = H->data[H->size--];  // 拿到最后一个位置的哈夫曼树 
	for (parent = 1; parent * 2 <= H->size; parent = child) 
	{
		// 左右儿子中挑小的 
		child = parent * 2;
		if ((child != H->size) && (H->data[child + 1]->weight < H->data[child]->weight))
			child++;
		// 没有更小的了，结束循环 
		if (Huff->weight <= H->data[child]->weight)
			break;
		// 否则把儿子结点拿上来
		H->data[parent] = H->data[child];
	}
	H->data[parent] = Huff;
	return T;
}

// 堆的插入
void Insert(MinHeap H, HuffmanTree Huff) 
{
	int i = ++H->size;
	for (; Huff->weight < H->data[i / 2]->weight; i /= 2)
		H->data[i] = H->data[i / 2];
	H->data[i] = Huff;
}

// 哈夫曼树的构造 
HuffmanTree Huffman(MinHeap H) 
{
	HuffmanTree Huff;
	int times = H->size;
	for (int i = 1; i < times; i++) 
	{
		Huff = createHuffman();
		Huff->left = Delete(H);  // 从堆中删除一个结点，作为新T的左子结点 
		Huff->right = Delete(H);  // 从堆中删除一个结点，作为新T的右子结点 
		Huff->weight = Huff->left->weight + Huff->right->weight; // 重新计算权值 
		Insert(H, Huff);   // 再加进堆中 
	}
	Huff = Delete(H);
	return Huff;
}

// 计算HuffmanTree的编码长度 
int WPL(HuffmanTree Huff, int depth) 
{
	// 如果是叶结点，返回编码长度 
	if (Huff->left == NULL && Huff->right == NULL)
		return depth * Huff->weight;
	else  // 否则返回其左右子结点的编码长度 
		return (WPL(Huff->left, depth + 1) + WPL(Huff->right, depth + 1));
}

// 判断是否正确 
void judge(int n, int codeLen) 
{
	HuffmanTree Huff = createHuffman();
	HuffmanTree pre;
	int counter = 1;
	bool flag = true;
	char ch;
	string code;
	for (int i = 0; i < n; i++) 
	{
		getchar();
		pre = Huff;
		// 读入每行 
		cin >> ch;
		cin >> code;
		// 遍历编码 
		for (int j = 0; j < code.size(); j++) 
		{
			if (code[j] == '0') 
			{  // 如果当前编码为0，左分支 
				if (pre->left == NULL) 
				{   // 如果左子树不存在，创建 
					pre->left = createHuffman();
					counter++;
				}
				if (pre->weight != 0)
					flag = false;
				pre = pre->left;
			}
			else if (code[j] == '1') 
			{ // 如果当前编码为 0，左分支 
				if (pre->right == NULL) 
				{   // 如果左子树不存在，创建 
					pre->right = createHuffman();
					counter++;
				}
				if (pre->weight != 0)
					flag = false;
				pre = pre->right;
			}
		}
		if (pre->left || pre->right)
			flag = false;
		pre->weight = mappp[ch];   // 从mapp取出存的频率
	}
	if (counter != 2 * n - 1 || !flag || WPL(Huff, 0) != codeLen) 
	{ // 如果结点不是2n-1个或者编码长度不相等 
		cout << "No" << endl;
		return;
	}
	else 
	{
		cout << "Yes" << endl;
		return;
	}
}

int main() 
{
	int n, m;
	cin >> n;
	// 初始化最小堆 
	MinHeap H = InitHeap(n);
	// 初始化哈夫曼树 
	HuffmanTree Huff = Huffman(H);
	// 计算该哈夫曼树的编码长度 
	int codeLen = WPL(Huff, 0);
	cin >> m;
	for (int i = 0; i < m; i++)
		judge(n, codeLen);
	system("pause");
	return 0;
}

  测试： 输入样例的测试效果如下图所示。