1022_哈夫曼树与译码

哈夫曼编码与译码

时间限制(普通/Java) :  1000 MS/ 3000 MS          运行内存限制 : 65536 KByte
总提交 : 573            测试通过 : 213 

比赛描述

已知电文包括的字符集为{A，C，I，M，N，P，T，U}，输入对应权值，对字符集合进行哈夫曼编码，完成电文的哈夫曼编码与译码工作。

输入

共三行：

第一行为对应字符集{A，C，I，M，N，P，T，U}的权值

第二行为一段字符串表示的电文(长度不超过1000）；

第三行为一段电文的哈夫曼编码。

输出

共十行：

前八行为各字符的编码；

第九行是与第二行输入对应的哈夫曼编码；

第十行是与第三行输入对应的电文。

样例输入

1 2 3 4 5 6 7 8
NUPTICPCACM
1111011111100

样例输出

A: 11110
C: 11111
I: 1110
M: 100
N: 101
P: 110
T: 00
U: 01
1010111000111011111110111111111011111100
ACM

提示

2012.4.11 更新

题目来源

NUPT ACM

功能已经实现，VS上编译通过，但g++编译器编译失败。原因（for each）

代码入下：

#include <iostream>
#include <list>
#include <string>
#include <cctype>
using namespace std;

struct BTnode
{
	char name=' ';
	int Weight;
	BTnode *LChild = NULL;
	BTnode *RChild = NULL;
	string code="";
};

bool Comp1(const BTnode *node1, const BTnode *node2);
bool Comp2(const BTnode *node1, const BTnode *node2);
void PreOrder(BTnode * root, list<BTnode *> & nList);

int main()
{
	char ch[8] = { 'A','C','I','M','N','P','T','U' };
	list<BTnode *> NodeList;//用于存入结点
	for (int i = 0; i < 8; i++)//第一行,初始化8个树，并且存入链表
	{
		BTnode *node = new BTnode();
		node->name = ch[i];
		cin >> node->Weight;
		NodeList.push_front(node);
	}

	string line2;//第二行
	cin >> line2;

	string line3;//第三行
	cin >> line3;

	NodeList.sort(Comp1);//按权值排序
	while (NodeList.size() != 1)//构造哈夫曼树
	{
		BTnode *FirstNode = NodeList.front();
		NodeList.pop_front();
		BTnode *SecondNode = NodeList.front();
		NodeList.pop_front();
		
		BTnode *NewNode = new BTnode;
		NewNode->Weight = FirstNode->Weight + SecondNode->Weight;
		NewNode->LChild = FirstNode;
		NewNode->RChild = SecondNode;

		NodeList.push_back(NewNode);
		NodeList.sort(Comp1);
	}
	
	BTnode *root = NodeList.front();//root存储根结点
	NodeList.clear();//清空链表，便于存储更新code的结点

	PreOrder(root, NodeList);//先序遍历求出编码，顺带把结点存入list
	
	NodeList.sort(Comp2);//按字母排序，便于输出

	for each (BTnode* node in NodeList)//输出前8行
	{
		cout << node->name << ": " << node->code << endl;
	}
	
	
	for each (char a in line2)//输出第9行
	{
		for each (BTnode* node in NodeList)
		{
			if (node->name == a)
				cout << node->code;
		}
	}
	cout << endl;

	BTnode *node = root;//输出第10行
	for each (char a in line3)
	{
		if (a == '0')
			node = node->LChild;
		else
			node = node->RChild;

		if (isalpha(node->name))
		{
			cout << node->name;
			node = root;
		}
	}
	cout << endl;
	
	return 0;
}

bool Comp1(const BTnode *node1, const BTnode *node2)//排序比较函数
{
	return node1->Weight < node2->Weight;
}

bool Comp2(const BTnode *node1, const BTnode *node2)
{
	return node1->name < node2->name;
}

void PreOrder(BTnode * root, list<BTnode *> & nList)
{
	if (root == NULL)
		return;

	if (isalpha(root->name))
		nList.push_front(root);

	if (root->LChild)
	{
		root->LChild->code = root->code + "0";
		PreOrder(root->LChild, nList);
	}
	if (root->RChild)
	{
		root->RChild->code = root->code + "1";
		PreOrder(root->RChild, nList);
	}
}