南邮 OJ 1022 哈夫曼编码与译码

最新推荐文章于 2024-01-01 15:59:51 发布
最新推荐文章于 2024-01-01 15:59:51 发布
阅读量1k 收藏 2
点赞数
分类专栏： 南邮 OJ 文章标签： 南邮OJ ACM 哈夫曼 编码与译码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/changshu1/article/details/47252741
版权

哈夫曼编码与译码

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

比赛描述

已知电文包括的字符集为{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


 

#include <iostream>
#include <cassert>
#include <string>
#define MAX(a,b) (a>b?a:b)
using namespace std;

template<typename Type>
class QueueNode{
public:
	Type data;
	QueueNode *next;
};

template<typename Type>
class Queue{
public:
	QueueNode<Type> *Head;			//指向第一个元素，方便出队
	QueueNode<Type> *Tail;			//指向最后一个元素，方便插入

	void PushBack(const Type&);
	Type PopFront(void);
};

/*
*函数功能：队尾加入新元素
*入口参数：const Type& data：将要插入的元素
*出口参数：无
*作者：陈汝军
*时间：2014-8-19 20:17:13
*/
template<typename Type>
void Queue<Type>::PushBack(const Type& data){
	if(Head == NULL){
		Head = new QueueNode<Type>();
		Head->data = data;
		Tail = Head;
	}else{
		Tail->next = new QueueNode<Type>();
		Tail->next->data = data;
		Tail = Tail->next;	
	}
}
/*
*函数功能：队首弹出元素
*入口参数：无
*出口参数：Type PopFront：弹出的元素
*作者：陈汝军
*时间：2014-8-19 20:18:08
*/ 
template<typename Type>
Type Queue<Type>::PopFront(void){
	QueueNode<Type> *TempHead = Head;
	Type TempData = Head->data;
	assert(Head!=NULL);
	Head = Head->next;
	delete TempHead;
	return TempData;
}


template<typename Type>
class BTNode{
public:
	Type data;
	BTNode *lChild;
	BTNode *rChild;
	BTNode *parent;

	void PreOrder(void);
	void InOrder(void);
	void PostOrder(void);
	static void PreOrderInput(BTNode<Type>* &Head);		//静态成员函数，调用与具体的类无关
	int  Height(void);
	int  NodeNum(void);
	int  LeafNum(void);
	void TransLevel(void);
	void Exchange(void);
};


/*
*函数功能：先序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:01:59
*/

template<typename Type>
void BTNode<Type>::PreOrder(){
	if(this == NULL)
		return;
	cout<<" "<<this->data;
	this->lChild->PreOrder();
	this->rChild->PreOrder();
}
/*
*函数功能：中序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:03:36
*/
template<typename Type>
void BTNode<Type>::InOrder(){
	if(this == NULL)
		return;
	this->lChild->InOrder();
	cout<<" "<<this->data;
	this->rChild->InOrder();	
}
/*
*函数功能：后序遍历二叉树。
*入口参数：this.
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:04:09
*/
template<typename Type>
void BTNode<Type>::PostOrder(){
	if(this == NULL)
		return;
	this->lChild->PostOrder();
	this->rChild->PostOrder();
	cout<<" "<<this->data;
}
/*
*函数功能：先序输入二叉树，用#代表空树或空子树。
*入口参数：BTNode* &Head：树的节点指针的引用
*出口参数：无
*作者：陈汝军
*时间：2014-8-18 22:01:59
*/
template<typename Type>
void BTNode<Type>::PreOrderInput(BTNode* &Head){
	Type data;
	cin>>data;
	if(data == '#'){
		Head = NULL;	
	}else{
		Head = new BTNode<Type>();
		Head->data = data;
		BTNode<char>::PreOrderInput(Head->lChild);
		BTNode<char>::PreOrderInput(Head->rChild);	
	}
}
/*
*函数功能：输出二叉树的高度
*入口参数：this：本节点指针
*出口参数：Height：高度
*作者：陈汝军
*时间：2014-8-19 10:21:03
*/
template<typename Type>
int BTNode<Type>::Height(void){
	if(this == NULL){
		return 0;
	}else{
		return MAX(this->lChild->Height(),this->rChild->Height())+1;
	}
}
/*
*函数功能：求二叉树的总结点数
*入口参数：this：本节点指针
*出口参数：NodeNum：以本节点为树根的总节点数
*作者：陈汝军
*时间：2014-8-19 10:24:16
*/
template<typename Type>
int BTNode<Type>::NodeNum(void){
	if(this == NULL){
		return 0;
	}else{
		return this->lChild->NodeNum()+this->rChild->NodeNum()+1;
	}	
}
/*
*函数功能：求二叉树的叶节点数
*入口参数：this：本节点指针
*出口参数：LeafNum：以本节点为树根的叶节点数
*作者：陈汝军
*时间：2014-8-19 10:29:36
*/
template<typename Type>
int BTNode<Type>::LeafNum(void){
	if(this==NULL){
		return 0;
	}else if(this->lChild==NULL && this->rChild==NULL){
		return 1;
	}else{
		return this->lChild->LeafNum()+this->rChild->LeafNum();
	}	
}
/*
*函数功能：层次遍历二叉树
*入口参数：无
*出口参数：无
*作者：陈汝军
*时间：2014-8-19 20:48:29
*/
template<typename Type>
void BTNode<Type>::TransLevel(void){
	Queue<BTNode<Type>*> *que = new Queue<BTNode<Type>*>();
	if(this == NULL)
		return;
	que->PushBack(this);
	while(que->Head!=NULL){					//输出整个队列，输出过程中队列在增长
		if(que->Head->data->lChild!=NULL){
			que->PushBack(que->Head->data->lChild);
		}
		if(que->Head->data->rChild!=NULL){
			que->PushBack(que->Head->data->rChild);
		}
		cout<<" "<<que->PopFront()->data;
	}
}
/*
*函数功能：二叉树上所有左右子树互换
*入口参数：无
*出口参数：无
*作者：陈汝军
*时间：2014-8-20 19:20:40
*/
template<typename Type>
void BTNode<Type>::Exchange(void){
	BTNode<Type> *Temp;
	if(this == NULL){
		return;
	}
	if(this->lChild!=NULL || this->rChild!=NULL){
		Temp = this->lChild;
		this->lChild = this->rChild;
		this->rChild = Temp;
	}
	this->lChild->Exchange();
	this->rChild->Exchange();
}
///上面是通用模板
class HufCode{
public:
	char ch;
	int weight;
};

typedef BTNode<HufCode> HufTree;
class HufLink{
public:
	HufTree *hTree;
	HufLink *next;
	void InsertAndSort(char newchar,int newweight);
	void InsertAndSort(HufLink *newLink);
	void outputList(void);
};
ostream& operator<<(ostream &out,const HufCode &hCode)           //我是输出操作符的重载
{
	out<<hCode.weight<<" "<<hCode.ch<<endl;
 return out;
}
/*
*函数功能：往HufLink中插入一个新元素。
*入口参数：char newchar：新元素的ch值
           int newweight：新元素的weight值
*出口参数：无
*作者：陈汝军
*时间：2014-8-21 09:06:14
*/
void HufLink::InsertAndSort(char newchar,int newweight){
	HufLink *p=this;
	HufLink *q=new HufLink();
	q->hTree = new HufTree();
	q->hTree->data.ch = newchar;
	q->hTree->data.weight = newweight;
	if(p->next == NULL){		//链表中一个元素也没有
		p->next = q;
		return;
	}
	while(p->next!=NULL && p->next->hTree->data.weight<newweight){
		p = p->next;
	}
	q->next = p->next;
	p->next = q;
}
/*
*函数功能：往HufLink中插入一个已经存在的新元素。
*入口参数：HufLink *newLink：指向新元素的指针
*出口参数：无
*作者：陈汝军
*时间：2014-8-21 09:07:00
*/
void HufLink::InsertAndSort(HufLink *newLink){
	HufLink *p=this;
	if(p->next == NULL){		//链表中一个元素也没有
		p->next = newLink;
		return;
	}
	while(p->next!=NULL && p->next->hTree->data.weight<newLink->hTree->data.weight){
		p = p->next;
	}
	newLink->next = p->next;
	p->next = newLink;
}
/*
*函数功能：从头到尾输出Huffman链表
*入口参数：无
*出口参数：无
*作者：陈汝军
*时间：2014-8-20 20:01:45
*/
void HufLink::outputList(void){
	HufLink *p=this->next;			//头指针没有元素
	while(p!=NULL){
		cout<<p->hTree->data.ch<<":"<<p->hTree->data.weight<<endl;
		p = p->next;
	}
}

/*HufLink里面存放*HufCode是建立不好树的，HufLink中应该存放HufTree*/
HufTree* makeHufTree(HufLink* hLink){
	HufLink *p,*q,*newNode;
	if(hLink==NULL || hLink->next==NULL){	//HufLink头指针不存放元素
		return NULL;
	}
	while(hLink->next->next!=NULL){
		newNode = new HufLink();
		newNode->hTree = new HufTree();
		p = hLink->next;
		q = hLink->next->next;
		newNode->hTree->data.weight = p->hTree->data.weight+q->hTree->data.weight;
		if(p->hTree->data.weight<q->hTree->data.weight){
			newNode->hTree->lChild = p->hTree;		//左小右大
			newNode->hTree->rChild = q->hTree;
			p->hTree->parent = newNode->hTree;
			q->hTree->parent = newNode->hTree;
		}else{
			newNode->hTree->lChild = q->hTree;		//左小右大
			newNode->hTree->rChild = p->hTree;
			p->hTree->parent = newNode->hTree;
			q->hTree->parent = newNode->hTree;
		}
		hLink = hLink->next->next;
		hLink->InsertAndSort(newNode);
	}
	return hLink->next->hTree;
}
class CodeLink{						//头指针不放元素
public:
	bool codebit;
	CodeLink *next;
	void addBit(bool bit);
	void reverse(void);
};
void CodeLink::addBit(bool bit){
	CodeLink *p=this,*q=new CodeLink();
	q->codebit = bit;
	if(p->next ==NULL){
		p->next = q;
		return;
	}
	while(p->next!=NULL){
		p = p->next;
	} 
	p->next = q;
}
void CodeLink::reverse(void){
	CodeLink *p=this->next,*q=NULL;
	if(p == NULL){
		return;
	}
	while(p->next!=NULL){
		q = p->next;
		p->next = q->next;
		q->next = this->next;
		this->next = q;

	}
}
	
CodeLink* cLink[256]={NULL};	//所有ASCII码到Huffman码转换
void cLinks(HufTree* hTree){
	HufTree *p=hTree;
	if(hTree == NULL)
		return;
	if(p->lChild==NULL && p->rChild==NULL){	//是叶节点
		cLink[hTree->data.ch] = new CodeLink();
		while(p->parent!=NULL){
			if(p->parent->lChild == p){
				cLink[hTree->data.ch]->addBit(0);	//做孩子0
			}else{
				cLink[hTree->data.ch]->addBit(1);	//右孩子1
			}
			p = p->parent;
		}
		cLink[hTree->data.ch]->reverse();
	}
	cLinks(hTree->lChild);
	cLinks(hTree->rChild);
}
void printHufCode(char ch){
	CodeLink *p=cLink[ch]->next;
	while(p!=NULL){
		cout<<p->codebit;
		p = p->next;
	}
}
int main(void){
	int weight[256]={0},i=0;
	string str,num;
	HufLink *hLink = new HufLink();
	cin>>weight['A']>>weight['C']>>weight['I']>>weight['M']>>weight['N']>>weight['P']>>weight['T']>>weight['U'];
	cin>>str>>num;
	hLink->InsertAndSort('A',weight['A']);
	hLink->InsertAndSort('C',weight['C']);
	hLink->InsertAndSort('I',weight['I']);
	hLink->InsertAndSort('M',weight['M']);
	hLink->InsertAndSort('N',weight['N']);
	hLink->InsertAndSort('P',weight['P']);
	hLink->InsertAndSort('T',weight['T']);
	hLink->InsertAndSort('U',weight['U']);
//	hLink->outputList();
	HufTree *hTree = makeHufTree(hLink),*p=NULL;
//	hTree->PreOrder();
	cLinks(hTree);
	cout<<"A: ";printHufCode('A');cout<<endl;
	cout<<"C: ";printHufCode('C');cout<<endl;
	cout<<"I: ";printHufCode('I');cout<<endl;
	cout<<"M: ";printHufCode('M');cout<<endl;
	cout<<"N: ";printHufCode('N');cout<<endl;
	cout<<"P: ";printHufCode('P');cout<<endl;
	cout<<"T: ";printHufCode('T');cout<<endl;
	cout<<"U: ";printHufCode('U');cout<<endl;
	while(str[i]!='\0'){
		printHufCode(str[i]);
		++i;
	}
	cout<<endl;
	p = hTree;
	i = 0;
	while(num[i]!='\0'){		
		if(num[i] == '0'){
			p = p->lChild;
		}else{
			p = p->rChild;
		}
		if(p->lChild==NULL && p->rChild==NULL){				//叶节点
			cout<<p->data.ch;
			p = hTree;
		}
		++i;
	}
	cout<<endl;
	return 0;
}



chenrujun2010
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼编码 wustOJ
Key的博客
11-13 754
1010: 哈夫曼编码 Time Limit: 1 Sec  Memory Limit: 65535 MB   64bit IO Format: %lld Submitted: 19  Accepted: 3 [Submit][Status][Web Board] Description （1）首先构造哈夫曼树，原则是左孩子结点权值小于右孩子权值，如果结点权值有相等的，按照
OJ 赫夫曼编码
zerou8400的博客
04-13 1155
描述先从键盘输入若干电文所用符号及其出现的频率，然后构造赫夫曼树，从而输出赫夫曼编码。注意：为了保证得到唯一的赫夫曼树，这里规定在构造赫夫曼树时，左孩子结点权值不大于右孩子结点权值，如若有多种选择，则尽量先选序号偏小的结点。编码时，左分支取“0”，右分支取“1”输入3行第1行：符号个数n（2～20）；第2行：符号，用空格分隔；第3行：各符号出现频率（用乘以100后的整数），用空格分隔；输出各符号对...
数据结构实验之二叉树六：哈夫曼编码 oj
七九河开的博客
01-25 411
数据结构实验之二叉树六：哈夫曼编码 Time Limit: 1000MS Memory Limit: 65536KB Problem Description 字符的编码方式有多种，除了大家熟悉的ASCII编码，哈夫曼编码(Huffman Coding)也是一种编码方式，它是可变字长编码。该方法完全依据字符出现概率来构造出平均长度最短的编码，称之为最优编码。哈夫曼编
Hduoj1053 【哈夫曼编码】
乐着过一辈子的专栏
12-28 657
#include #include #include int cmp(const void *a, const void *b) { return *(int *) b - *(int *) a; } int main() { int i, j, k, n, t, a[30]; char s[1001]; while(gets(s)) { i
哈夫曼编码
became_a_wolf的专栏
11-05 2517
数据结构实验之二叉树六：哈夫曼编码 Time Limit: 1000MS Memory limit: 65536K 题目描述 字符的编码方式有多种，除了大家熟悉的ASCII编码，哈夫曼编码(Huffman Coding)也是一种编码方式，它是可变字长编码。该方法完全依据字符出现概率来构造出平均长度最短的编码，称之为最优编码。哈夫曼编码常被用于数据文件压缩中，其压缩率通常在
OJ哈夫曼译码.cpp
06-03
西南科技大学学生
哈夫曼树编码参考代码
05-01
- 函数声明，例如`createNode(char, int)`用于创建新的哈夫曼节点，`buildHuffmanTree(priority_queue*>&)`用于构建哈夫曼树，`generateCodes(HuffmanNode*, string, string)`用于生成哈夫曼编码。 2. **main函数...
数据结构与算法Python版第十一周OJ作业
01-20
1 找到小镇的法官（10分） 题目内容： 在一个小镇里，按从 1 到 N 标记了 N 个人。传言称，这些人中有一个是小镇上的秘密法官。 如果小镇的法官真的存在，那么： 小镇的法官不相信任何人。 每个人（除了小镇法官外）...
数据结构与算法Python版第九周OJ作业
01-20
1 二叉树复原（10分） 题目内容： 给定一种序列化二叉树的方式：从根节点起始按层次遍历二叉树所有“可能”...一行合法的Python表达式，可解析为包含整数与None的列表 输出格式： 二叉树中序遍历的整数序列，以空格分隔
Java数据结构与算法，笔试题，OJ.zip
最新发布
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
赫哈曼编码的应用对输入的一串字符实现赫夫曼编码，再对赫夫曼编码生成的代码串进行译码，输出电文字符串
03-24
本设计要求是对输入的一串字符实现赫夫曼编码，再对赫夫曼编码生成的代码串进行译码，输出电文字符串。赫夫曼编码是一种将信息转换成二进制编码有效的方法之一，赫夫曼编码是利用赫夫曼树求得的用于通信的二进制编码。而这次我们的课程设计对编码译码的要求不是太高，只是将大写字母或小写字母转化成二进制编码，或将二进编码转化成大写字母或小写字母，虽然功能有一点局限，但也是一次成功的尝试，能满足一般的需求
哈夫曼编码C++实现
03-25
哈夫曼编码是广泛用于数据文件压缩的十分有效的编码方式，其压缩率通常在20%—90%之间。哈夫曼编码算法是通过使用字符在文件中出现的频率表来构造最优前缀码的贪心算法。所谓前缀码，即是任一字符的编码都不是其他字符编码的前缀。哈夫曼算法以自底向上的方式，将各字符（n个）存在叶节点中，通过n-1次合并，来产生表示最优前缀码的完全二叉树。
数据结构OJ实验8-赫夫曼树编码及应用
gyeolhada的博客
01-01 1072
数据结构OJ实验8-赫夫曼树编码及应用
算法导论OJ-哈夫曼编码
m0_54002804的博客
11-06 282
算法导论OJ-哈夫曼编码一、原题目1.题目描述2.输入3.输出4.样例输入5.样例输出二、代码 一、原题目 1.题目描述 给定一只含有小写字母的字符串；输出其哈夫曼编码的长度 2.输入 第一行一个整数T，代表样例的个数，接下来T行，每行一个字符串，0<T<=2000,字符串长度0<L<=1500. 3.输出 对于每个字符串，输出其哈夫曼编码长度 4.样例输入 3 hrvsh lcxeasexdphiopd mntflolfbtbpplahqolqykrqdnwdoq
【学校OJ】 贪心 哈夫曼编码
Starlight的博客
01-20 1168
题目描述 输入N个整数表示N个叶节点权值，构造一棵最优二叉树，从左向右输出每个叶节点的哈夫曼编码。 输入 第1行:1个整数N（N≤50）第2行：N个空格分开的整数 输出 共N行，每行表示1个叶节点的编码。 样例输入 Copy (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制) 3 1 2 4 样例输出 00
<OJ_Sicily>Huffman coding哈夫曼编码
Vipin_Pei的博客
04-25 1890
实现哈夫曼编码
哈夫曼译码 swustoj
yyx的博客
05-22 2685
哈夫曼译码 1000(ms) 10000(kb) 1570 / 3422通常要求根据给定的编码本对密文进行解码。现已给定相应字符的哈夫曼编码，要求根据编码对密文进行解码。（建立哈夫曼树以及编码、主函数等都已经给出，你只需要填写译码函数void ccode(haffnode  hafftree[],int n)即可。const int maxvalue=100;const int maxbit=10...
哈夫曼编码oj(堆)&多元Huffman编码问题（贪心）
weixin_44040169的博客
11-04 660
数据结构实验之二叉树六：哈夫曼编码 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 字符的编码方式有多种，除了大家熟悉的ASCII编码，哈夫曼编码(Huffman Coding)也是一种编码方式，它是可变字长编码。该方法完全依据字符出现概率来构造出平均长度最短的编码，称之为最优编码。哈夫曼编码常被用于数据文件压缩中，其...
OJ百练
SAM2un的博客
06-28 679
4080——Huffman编码树 总时间限制: 1000ms 内存限制: 65536kB 描述 构造一个具有n个外部节点的扩充二叉树，每个外部节点Ki有一个Wi对应，作为该外部节点的权。使得这个扩充二叉树的叶节点带权外部路径长度总和最小： Min( W1 * L1 + W2 * L2 + W3 * L3 + … + W
自底向上的哈夫曼编码(oj-1804)
06-08
自底向上的哈夫曼编码是一种构建哈夫曼树的方法，它与传统的从上往下构建哈夫曼树的方法不同。下面是自底向上的哈夫曼编码的步骤： 1. 对于给定的n个权值，将它们看作n棵只有一个节点的树，即森林F={T1,T2,...,Tn}...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值