哈夫曼树的应用——课程设计

最新推荐文章于 2024-07-17 16:17:24 发布
最新推荐文章于 2024-07-17 16:17:24 发布
阅读量1.1w 收藏 187
点赞数 35
文章标签： 课程设计 哈夫曼树的应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiqi123i/article/details/53885297
版权

这个是我去年的课程设计报告，因为有学弟要我就整理了下，功能很简单，就一个加密解密还有求哈夫曼编码，但足够满足老师的要求，现在传给有需要的童鞋参考~


完整的代码及报告


以下是实验报告内容

哈夫曼树的应用——对文件进行解码和译码

一、       需求分析说明

随着信息时代的到来，信息越来越多，如何压缩信息已经是重要课题。特别是多媒体技术的发展，使得信息量大的问题凸显。

哈夫曼编码(Huffman Coding)是一种无损压缩编码方式，以哈夫曼树—即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。在计算机信息处理中，“哈夫曼编码”是一种一致性编码法（又称"熵编码法"），用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。这种方法是由David.A.Huffman发展起来的。例如，在英文中，e的出现概率很高，而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时，e极有可能用一个位(bit)来表示，而z则可能花去 25个位（不是26）。用普通的表示方法时，每个英文字母均占用一个字节（byte），即8个位。二者相比，e使用了一般编码的1/8的长度，z则使用了 3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

当然本软件的目的不在于如何去压缩一个文件信息，而是通过建立哈夫曼树，由哈夫曼树编得二进制码，再译码，来了解哈夫曼树编码实现过程。(庞大的翻译内容会进行报错)

 

二、       主要功能

1.统计文件中各个字符出现的个数;                      

2.对文件进行处理得到哈夫曼树编码;                   

3.对文件进行加密;                        

4.对文件进行解码  

三、       所运用到的知识点

（1）链式存储结构（用来从文件中读取数据，构造哈夫曼编码）

（2）队列的应用（主要用在解码那一块，从文件中逐个读取字符，进入队列，再一个一个判断是否是哪个编码值）

（3）构造最优二叉树，对树的基本操作

（4）对文件的操作（打开文件，读写文件）

四、核心代码实现

（一）   菜单块

while (i != 0)
	{
		cout << "***********************欢迎使用译码器（解码器）**************************" << endl;
		cout << "                  1.统计文件中各个字符出现的个数;                        " << endl;
		cout << "                  2.对文件进行处理得到哈夫曼树编码;                      " << endl;
		cout << "                  3.对文件进行加密;                                      " << endl;
		cout << "                  4.对文件进行解码                                       " << endl;
		cout << "                  0.退出                                                 " << endl;
		switch (i)
		{
		case 1:
			List.creatlist();
			List.disp();
			List.total(); break;
		case 2:
			L.CreateHT();
			L.CreateHCode();
			L.DispHCode(); break;
		case 3:
			L.CreateHT();
			L.CreateHCode();
			L.Revertext(); break;
			/*	case 0:
			exit(0);*/
		case 4:   /*将二进制转化为字母*/
			L.CreateHT();
			L.CreateHCode();
			L.decode(); break;
		case 0:
			cout << "欢迎下次使用译码器（解码器）" << endl;
			break;
		}
		cout << "请输入您要进行的操作：";
		cin >> i;
		system("cls");
	}
 

（二）   统计字符

void total()                           //利用一个数组，统计字母出现次数
	{
		linklist *s;
		int j = 0;
		int count[127] = { 0 };             //设置初始化
		s = head->next;
		int num;
		while (s)
		{
			num = s->data;
			if (num != 32)               //不计算空格出现的频度
			{
				count[num - 0]++;
			}
			s = s->next;
		}
		cout << "统计" << endl;
		cout << "|---------------------------------------------|" << endl;
		cout << "|   字母              |               频度    |" << endl;
		for (int i = 0; i < 127; i++)
		{
			if (count[i])
			{
				aa[j].data = i;
				aa[j].weight = count[i];
				j++;
				cout << "|    " << char(i) << "                |            " << setw(6) << count[i] << "     |" << endl;
			}
		}
		Count = j;
		cout << "|---------------------------------------------|" << endl;
		cout << "出现的字母种类为：" << Count << "个" << endl;
		cout << endl;

	}
};

（三）   创建哈夫曼树

void HuffmanClass<T>::CreateHT()               //构造哈夫曼树
{
	int i, k, lnode, rnode;
	double min1, min2;
	for (i = 0; i < (2 * no - 1); i++)                    //所有结点的相关域置初值-1
	{
		ht[i].parent = -1;
		ht[i].lchild = -1;
		ht[i].rchild = -1;
	}
	for (i = no; i < (2 * no - 1); i++)                  //构造哈夫曼树，仅求非叶子结点
	{
		min1 = min2 = 32767.0;                          //初始时置最大权值
		lnode = rnode = -1;                             //lnode和rnode为两个权重最小的节点位置
		for (k = 0; k <= (i - 1); k++)                   //在ht数组中找权值最小的两个结点

		if (ht[k].parent == -1)                      //只在二叉树的根节点中寻找
		{
			if (ht[k].weight < min1)
			{
				min2 = min1;
				rnode = lnode;
				min1 = ht[k].weight;
				lnode = k;
			}
			else if (ht[k].weight < min2)
			{
				min2 = ht[k].weight;
				rnode = k;
			}
		}


		ht[lnode].parent = i;                   //把后面的no-1个非叶子结点处理完毕
		ht[rnode].parent = i;
		ht[i].weight = ht[lnode].weight + ht[rnode].weight;
		ht[i].lchild = lnode;                                 //ht[i]作为双亲结点
		ht[i].rchild = rnode;
	}
}

（四）   得到哈夫曼编码

void HuffmanClass<T>::CreateHCode()                       //根据哈夫曼树求哈夫曼编码
{
	int i, f, c;
	for (i = 0; i < no; i++)                            //遍历下标从0到no-1的叶子结点
	{
		hcd[i].start = no;                              //从hcd[i].cd[no]开始放置哈夫曼编码
		c = i;
		f = ht[i].parent;                               //找其双亲结点
		while (f != -1)                                 //循环直至无双亲结点即到达树根结点
		{
			if (ht[f].lchild == c)                       //当前结点是双亲结点的左孩子结点
			{
				hcd[i].cd[hcd[i].start] = '0';
				/*cout << hcd[i].cd[hcd[i].start]<<endl;*/
			}
			else
			{
				hcd[i].cd[hcd[i].start] = '1';
			}//当前结点是双亲结点的右孩子结点

			hcd[i].start--;
			c = f;
			f = ht[f].parent;                        //再对双亲进行同样的操作
		}
		hcd[i].start++;                   //start指向哈夫曼编码最开始字符
	}
}

（五）   对文件进行加密

void  HuffmanClass<T>::Revertext()
{
	SqQueueClass<char> L;
	L.initQueue();
	FILE *fin, *fout;
	char ch;
	if ((fin = fopen("D:\\test.txt", "r")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	if ((fout = fopen("D:\\tex.txt", "w")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	ch = fgetc(fin);//一个一个读出来
	while (!feof(fin))
	{
		for (int i = 0; i < no; i++)
		{
			if (ch == ht[i].data)
			{
				for (int j = hcd[i].start; j <= no; j++)
				{
					cout << hcd[i].cd[j];
					fputc(hcd[i].cd[j], fout);
				}
			}
		}
		ch = fgetc(fin);  //从fin 文件中打开,再次读
	}
	cout << endl << "文件已经读写完毕，这是显示器的输出效果" << endl;
	fclose(fin);
	fclose(fout);
}

（六）   对文件进行解码

void HuffmanClass<T>::decode()//解码
{
	cout << "文件解码为:" << endl;
	int mark = 0;//设置标志
	int q, j, ii, jj, k, tt;
	int kk = 0;
	char temp[MaxQueue][MaxQueue];
	char temp1[MaxQueue][MaxQueue];
	SqQueueClass<char> L;
	L.initQueue();
	FILE *fin;
	char ch;
	if ((fin = fopen("D:\\test1.txt", "r")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	for (int aa = 0; aa < no; aa++)
	{
		for (int bb = hcd[aa].start; bb <= no; bb++)
		{
			temp1[aa][(bb - hcd[aa].start)] = hcd[aa].cd[bb];
			/*cout << temp1[aa][(bb - hcd[aa].start)] << " ";*/    /*保留*/
		}
	}
	ch = fgetc(fin);//一个一个读出来
	while (!feof(fin))
	{
		mark = 0;
		L.enQueue(ch);//进队

		for (j = 0, q = L.getfront() + 1; q != L.getrear() + 1; j++, q++)    //一个个获得临时的01(temp)序列，以便和哈夫曼编码比较
		{
			temp[kk][j] = L.data[q];
		}
		for (ii = 0; ii < no; ii++)//哈弗曼编码放到二维数组里了
		{
			int zz;
			zz = 0;
			for (jj = 0; jj <= no - hcd[ii].start; jj++)
			{
				if (temp[kk][jj] == temp1[ii][jj])//若两个相等
				{
					zz = zz + 1;
				}

			}
			if (zz == no - hcd[ii].start + 1)
			{
				cout << ht[ii].data;
				mark = 1; break;
			}

		}
		if (mark == 1)
		{
			L.destory();//清空队列
			/*cout << "清空" << endl;*/
		}
		ch = fgetc(fin);  //从fin 文件中打开,再次读
		kk = kk + 1;
	}
	if (L.getfront() != L.getrear())
	{
		cout << "\n以下二进制串输入有错误：";
		for (int j = L.getfront() + 1; j != L.getrear() + 1; j++)
			cout << L.data[j];
	}
	else
		cout << endl;
	cout << endl << "文件已经读写完毕，这是显示器的输出效果" << endl;
	fclose(fin);
}

五、       结果展示

菜单：


计算字符出现的频度：

 

得到哈夫曼编码：

加密：


解码：

六、       总结

做这个课程设计是熬了两个晚上做出来的，其中有一个如何解密，如何判断从文件读取的数据构成的数组与我的每一个哈夫曼编码值是否相等，因为哈夫曼编码的存储方式是存在数组，且从start元素到no元素才是正确的值，所以非常麻烦。我一直在不停地用循环判断，甚至要重新写我如何得到哈夫曼的编码，因为实在太困难了。索性，学到了一个好方法，就是中断，通过中断可以查看自己的程序走到哪一步了，再跟着步骤和本应该有的步骤进行对比，就很容易发现错误，这一次最大的收获就是学会熟练使用中断。还有可以用到之前学到的知识点，比如这里用了队列进行读取数据，以前从没有想过队列可以这样用。还有要集思广益，不一定去网上找代码就是不好的，因为适合别人的代码不一定适合自己，还是要自己写，主要是学习他们的思路，然后用自己的方法做出来。这个.cpp的功能其实还有缺陷，就是如果我对非常多的‘0’‘1’进行译码是会出现错误，我不知道是什么问题，不过会继续深入，另外还有一个可以提升的地方是对文件的操作应该是让用户自己选择文件而不是固定文件，不过，因为自己的代码太冗余，很难实现这个操作，不过会继续学习如何写出漂亮的代码。

 

完整的代码：

#include<iostream>
#include<fstream>
#include<iomanip>
#include<string>
using namespace std;
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
#define MaxQueue 100
struct linklist                                        //单链表结点类型
{
	char data;
	linklist *next;
};
struct pindu                                           //每个字母出现的频度结点类型
{
	char data;         //字母           
	int weight;        //权值
};
template <typename T>
struct HTNode                                          //哈夫曼结点类型
{
	T data;//结点值
	double weight;//权值
	int parent;//双亲结点
	int lchild;//左孩子结点
	int rchild;//右孩子结点
};

struct HCode                                           //哈夫曼编码类型
{
	char cd[MaxSize];              //存放当前结点的哈夫曼编码
	int start;                    //用cd[start..no]存放哈夫曼编码,包括start和no
};
class sqlist
{
private:
	linklist *head;
	int Count;                          //计算个数 
public:
	pindu aa[100];                      //存放频度的信息
	sqlist()
	{
		head = new linklist[100];
		head->next = NULL;
		Count = 0;
	}
	void destorysqlist()                     //删除单链表，不能用析构，因为随时不用，会对哈夫曼数的构造造成影响
	{
		linklist *pre, *p;
		pre = head;
		p = pre->next;
		while (p != NULL)
		{
			delete pre;
			pre = p; p = p->next;
		}
		delete pre;
	}
	int getCount()                       //得到权值个数
	{
		linklist *s;
		int j = 0;
		int count[127] = { 0 };             //设置初始化
		s = head->next;
		int num;
		while (s)
		{
			num = s->data;
			if (num != 32)               //不计算空格出现的频度
			{
				count[num - 0]++;
			}
			s = s->next;
		}
		for (int i = 0; i < 127; i++)
		{
			if (count[i])
			{
				aa[j].data = i;
				aa[j].weight = count[i];
				j++;
			}
		}
		Count = j;
		return Count;
	}
	void creatlist()                     //创建单链表，把文件中的字母写进单链表中
	{
		linklist *s, *r;
		r = head;
		FILE *fin;
		char ch;
		/*char filename[100] = { 0 };
		cout << "请输入文件路径：";
		cin >> filename;*/
		if ((fin = fopen("H:\\test.txt", "r")) == NULL)
		{
			cout << "无法打开此文件" << endl;
			exit(0);
		}
		ch = fgetc(fin);
		while (!feof(fin))
		{
			s = new linklist;
			s->data = ch;
			r->next = s;
			r = s;
			ch = fgetc(fin);  //从fin 文件中打开
		}
		r->next = NULL;
		fclose(fin);
		/*	cout << endl;
		cout << endl;*/
	}
	void disp()                                 //输出单链表内容，即文章内容
	{
		cout << endl << "文件内容打开如下" << endl;
		linklist *s;
		s = head->next;
		int count[257] = { 0 };
		while (s)
		{
			cout << s->data;
			s = s->next;
		}
		cout << endl;
	}
	void total()                           //利用一个数组，统计字母出现次数
	{
		linklist *s;
		int j = 0;
		int count[127] = { 0 };             //设置初始化
		s = head->next;
		int num;
		while (s)
		{
			num = s->data;
			if (num != 32)               //不计算空格出现的频度
			{
				count[num - 0]++;
			}
			s = s->next;
		}
		cout << "统计" << endl;
		cout << "|---------------------------------------------|" << endl;
		cout << "|   字母              |               频度    |" << endl;
		for (int i = 0; i < 127; i++)
		{
			if (count[i])
			{
				aa[j].data = i;
				aa[j].weight = count[i];
				j++;
				cout << "|    " << char(i) << "                |            " << setw(6) << count[i] << "     |" << endl;
			}
		}
		Count = j;
		cout << "|---------------------------------------------|" << endl;
		cout << "出现的字母种类为：" << Count << "个" << endl;
		cout << endl;

	}
};

template <typename T>
class SqQueueClass                                        //队列进行解码操作
{
private:
	int front;
	int rear;
public:
	T data[MaxQueue];
	void initQueue()//初始化
	{
		front = rear = 0;
	}
	void destory()//清空队列
	{
		initQueue();
	}
	void enQueue(T e)//进队
	{
		//if ((rear + 1) % MaxQueue == front)//队满
		//	return false;
		rear = (rear + 1) % MaxQueue;
		data[rear] = e;
	}
	void deQueue(T &e)//出队
	{
		/*if (rear == front)
		return false;*/
		front = (front + 1) % MaxQueue;
		e = data[front];
	}
	void disp()
	{
		for (int i = front + 1; i <= rear; i++)
		{
			cout << data[i] << " ";
		}
	}
	int getfront()
	{
		return front;
	}
	int getrear()
	{
		return rear;
	}
};

template <typename T>
class HuffmanClass
{
private:
	int no;                            //权值个数
	HTNode<T> ht[MaxSize];              //存放哈夫曼树
	HCode hcd[MaxSize];                 //存放哈夫曼编码
public:
	HuffmanClass();					            //Setvalue设置初值
	void CreateHT();                             //构造哈夫曼树
	void CreateHCode();                          //根据哈夫曼树求哈夫曼编码
	void DispHCode();                            //输出哈夫曼编码
	void Revertext();                            //将文本转化成二进制代码存入另一个文件中
	void decode();                                  //解码，把二进制转化成文字
};
template <typename T>
HuffmanClass<T>::HuffmanClass()                   //设置初值
{
	pindu str[100];
	sqlist List;//
	List.creatlist();//
	for (int i = 0; i < List.getCount(); i++)
	{
		str[i].data = List.aa[i].data;

		str[i].weight = List.aa[i].weight;
	}
	no = List.getCount();    //权值个数
	for (int i = 0; i <(2 * no - 1); i++)
	{
		ht[i].data = str[i].data;
		ht[i].weight = str[i].weight;
	}
}
template <typename T>

void HuffmanClass<T>::CreateHT()               //构造哈夫曼树
{
	int i, k, lnode, rnode;
	double min1, min2;
	for (i = 0; i < (2 * no - 1); i++)                    //所有结点的相关域置初值-1
	{
		ht[i].parent = -1;
		ht[i].lchild = -1;
		ht[i].rchild = -1;
	}
	for (i = no; i < (2 * no - 1); i++)                  //构造哈夫曼树，仅求非叶子结点
	{
		min1 = min2 = 32767.0;                          //初始时置最大权值
		lnode = rnode = -1;                             //lnode和rnode为两个权重最小的节点位置
		for (k = 0; k <= (i - 1); k++)                   //在ht数组中找权值最小的两个结点

		if (ht[k].parent == -1)                      //只在二叉树的根节点中寻找
		{
			if (ht[k].weight < min1)
			{
				min2 = min1;
				rnode = lnode;
				min1 = ht[k].weight;
				lnode = k;
			}
			else if (ht[k].weight < min2)
			{
				min2 = ht[k].weight;
				rnode = k;
			}
		}


		ht[lnode].parent = i;                   //把后面的no-1个非叶子结点处理完毕
		ht[rnode].parent = i;
		ht[i].weight = ht[lnode].weight + ht[rnode].weight;
		ht[i].lchild = lnode;                                 //ht[i]作为双亲结点
		ht[i].rchild = rnode;
	}
}
template <typename T>
void HuffmanClass<T>::CreateHCode()                       //根据哈夫曼树求哈夫曼编码
{
	int i, f, c;
	for (i = 0; i < no; i++)                            //遍历下标从0到no-1的叶子结点
	{
		hcd[i].start = no;                              //从hcd[i].cd[no]开始放置哈夫曼编码
		c = i;
		f = ht[i].parent;                               //找其双亲结点
		while (f != -1)                                 //循环直至无双亲结点即到达树根结点
		{
			if (ht[f].lchild == c)                       //当前结点是双亲结点的左孩子结点
			{
				hcd[i].cd[hcd[i].start] = '0';
				/*cout << hcd[i].cd[hcd[i].start]<<endl;*/
			}
			else
			{
				hcd[i].cd[hcd[i].start] = '1';
			}//当前结点是双亲结点的右孩子结点

			hcd[i].start--;
			c = f;
			f = ht[f].parent;                        //再对双亲进行同样的操作
		}
		hcd[i].start++;                   //start指向哈夫曼编码最开始字符
	}
}
template <typename T>
void HuffmanClass<T>::DispHCode()
{
	cout << "该文件哈夫曼编码如下" << endl;
	for (int i = 0; i < no; i++)
	{
		cout << ht[i].data << ":";
		for (int j = hcd[i].start; j <= no; j++)                 //因为start一直在变化，一直在减小，存的值是从下往上走的，就是start减小的顺序
		{
			cout << hcd[i].cd[j];
		}
		cout << endl;
	}
}


template <typename T>
void  HuffmanClass<T>::Revertext()
{
	SqQueueClass<char> L;
	L.initQueue();
	FILE *fin, *fout;
	char ch;
	if ((fin = fopen("H:\\test.txt", "r")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	if ((fout = fopen("H:\\tex.txt", "w")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	ch = fgetc(fin);//一个一个读出来
	while (!feof(fin))
	{
		for (int i = 0; i < no; i++)
		{
			if (ch == ht[i].data)
			{
				for (int j = hcd[i].start; j <= no; j++)
				{
					cout << hcd[i].cd[j];
					fputc(hcd[i].cd[j], fout);
				}
			}
		}
		ch = fgetc(fin);  //从fin 文件中打开,再次读
	}
	cout << endl << "文件已经读写完毕，这是显示器的输出效果" << endl;
	fclose(fin);
	fclose(fout);
}

template <typename T>
void HuffmanClass<T>::decode()//解码
{
	cout << "文件解码为:" << endl;
	int mark = 0;//设置标志
	int q, j, ii, jj, k, tt;
	int kk = 0;
	char temp[MaxQueue][MaxQueue];
	char temp1[MaxQueue][MaxQueue];
	SqQueueClass<char> L;
	L.initQueue();
	FILE *fin;
	char ch;
	if ((fin = fopen("H:\\test1.txt", "r")) == NULL)
	{
		cout << "无法打开此文件" << endl;
		exit(0);
	}
	for (int aa = 0; aa < no; aa++)
	{
		for (int bb = hcd[aa].start; bb <= no; bb++)
		{
			temp1[aa][(bb - hcd[aa].start)] = hcd[aa].cd[bb];
			/*cout << temp1[aa][(bb - hcd[aa].start)] << " ";*/    /*保留*/
		}
	}
	ch = fgetc(fin);//一个一个读出来
	while (!feof(fin))
	{
		mark = 0;
		L.enQueue(ch);//进队

		for (j = 0, q = L.getfront() + 1; q != L.getrear() + 1; j++, q++)    //一个个获得临时的01(temp)序列，以便和哈夫曼编码比较
		{
			temp[kk][j] = L.data[q];
		}
		for (ii = 0; ii < no; ii++)//哈弗曼编码放到二维数组里了
		{
			int zz;
			zz = 0;
			for (jj = 0; jj <= no - hcd[ii].start; jj++)
			{
				if (temp[kk][jj] == temp1[ii][jj])//若两个相等
				{
					zz = zz + 1;
				}

			}
			if (zz == no - hcd[ii].start + 1)
			{
				cout << ht[ii].data;
				mark = 1; break;
			}

		}
		if (mark == 1)
		{
			L.destory();//清空队列
			/*cout << "清空" << endl;*/
		}
		ch = fgetc(fin);  //从fin 文件中打开,再次读
		kk = kk + 1;
	}
	if (L.getfront() != L.getrear())
	{
		cout << "\n以下二进制串输入有错误：";
		for (int j = L.getfront() + 1; j != L.getrear() + 1; j++)
			cout << L.data[j];
	}
	else
		cout << endl;
	cout << endl << "文件已经读写完毕，这是显示器的输出效果" << endl;
	fclose(fin);
}


void menu()
{
	HuffmanClass <char>L;
	sqlist List;
	int i;
	cout << "***********************欢迎使用译码器（解码器）**************************" << endl;
	cout << "                  1.统计文件中各个字符出现的个数;                        " << endl;
	cout << "                  2.对文件进行处理得到哈夫曼树编码;                      " << endl;
	cout << "                  3.对文件进行加密;                                      " << endl;
	cout << "                  4.对文件进行解码                                       " << endl;
	cout << "                  0.退出                                                 " << endl;
	cout << "请输入您要进行的操作：";
	cin >> i;
	while (i != 0)
	{
		cout << "***********************欢迎使用译码器（解码器）**************************" << endl;
		cout << "                  1.统计文件中各个字符出现的个数;                        " << endl;
		cout << "                  2.对文件进行处理得到哈夫曼树编码;                      " << endl;
		cout << "                  3.对文件进行加密;                                      " << endl;
		cout << "                  4.对文件进行解码                                       " << endl;
		cout << "                  0.退出                                                 " << endl;
		switch (i)
		{
		case 1:
			List.creatlist();
			List.disp();
			List.total(); break;
		case 2:
			L.CreateHT();
			L.CreateHCode();
			L.DispHCode(); break;
		case 3:
			L.CreateHT();
			L.CreateHCode();
			L.Revertext(); break;
			/*	case 0:
			exit(0);*/
		case 4:   /*将二进制转化为字母*/
			L.CreateHT();
			L.CreateHCode();
			L.decode(); break;
		case 0:
			cout << "欢迎下次使用译码器（解码器）" << endl;
			break;
		}
		cout << "请输入您要进行的操作：";
		cin >> i;
		system("cls");
	}
}
int main()
{
	menu();
	system("pause");
	return 0;
}


代码注意事项：

软件：DEV C++
主要功能
1.统计文件中各个字符出现的个数;                      
2.对文件进行处理得到哈夫曼树编码;                   
3.对文件进行加密;                        
4.对文件进行解码  
1.在H盘上创建一个名为test.txt的文件，存放a-z任意字符；
2.在H盘创建一个名为test1.txt的文件，存放01字符；
3.在H盘创建一个名为tex.txt的文件（可以什么都不放）；
（可自行换盘，代码要改）
功能一：求test.txt的各个字符出现的频度；
功能二：求出哈夫曼编码（根据test.txt中的字符）；
功能三：对test.txt的文件进行加密（根据求得的哈夫曼编码来），然后把结果存放到tex.txt中；
功能四：是对test1中的01字符进行解码，翻译成对应的字符，将结果输出到屏幕；（就是根据功能二得到的哈夫曼树，对test1.txt的内容进行解码）

 

 

 


_ dingding_
关注
  • 35
    点赞
  • 踩
  • 187
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
数据结构——哈夫曼树及其应用
Labrador_Katie的博客
02-04 5465
哈夫曼树及其应用哈夫曼的基本概念 哈夫曼的基本概念 路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径 结点的路径长度：两结点间路径上的分支数 树的路径长度：从树根到每一个结点的路径长度之和，记作TL **结点数目相同的二叉树中，完全二叉树是路径最短的二叉树** ...
哈夫曼树的应用——数据结构课程设计
12-14
哈夫曼树的应用——数据结构课程设计 哈夫曼树是一种特殊的二叉树，它的每个叶子节点都对应一个权值，树的构建是根据权值的大小进行排序的。哈夫曼树的应用非常广泛，例如数据压缩、编码、解码等。 在数据结构课程...
数据结构课程设计-哈夫曼树及其应用
热门推荐
AIGC Studio：分享AIGC前沿知识和好玩应用，公众号同名。
12-19 1万+
题目：假设用于通信的电文由字符集{a,b,c,d,e,f,g,h,}中的字母构成，这8个字母在电文中出现的 频率分别为： {0.19, 0.21, 0.02, 0.03, 0.06, 0.07, 0.1, 0.32}. 要求：画出哈夫曼树。 我从课本上面摘抄了一个题目，题目大概是上面这样的，我们这里只是详细的说明一下哈弗曼树要怎么构建。借用一下这个题目。 分
数据结构课程设计实践--哈夫曼树
qq_55552561的博客
03-16 1057
4. 译码的过程是对二进制电文从根节点出发做自上而下搜搜，当搜搜到树叶结点时则确定了一段二进制电文对应的一个字符，这一搜索过程的时间复杂度是O(lg n),若二进制电文中可译出的字符数为m，则译码的过程的时间复杂度为O(m*lg n)2. 对每个字符的编码，是从树叶结点出发自下而上搜索至根结点的过程，这一搜索过程的时间复杂度为O(lg n)，对有n个树叶的哈夫曼树而言，建立编码表的时间复杂度为O(n*lg n)显示根据在内存中的或者从文件“hfmTree.txt”中读入的哈夫曼树建立的各个字符的编码。
哈夫曼树及其应用
狂放不羁霸的博客
06-24 1223
目录一、相关概念二、构建哈夫曼树三、哈夫曼树的存储结构和类型定义3.1 存储结构 3.2 类型定义 四、哈夫曼树的算法实现4.1 初始化哈夫曼树4.2 选出权重最小的两个结点4.3 构建哈夫曼树（1） 路径、路径长度和树的路径长度路径：从一个结点到另一个结点的分支序列。路径长度： 从一个结点到另一个结点所经过的分支数目。树的路径长度：从根结点到每个结点的路径长度之和。（2）结点的权和带权路径长度 结点的权：给树的每个结点赋予的一个具有实际意义的实数。带权路径长度：从根结点到某一结点的路径长度与该结点的权的
【哈夫曼树及其应用 c语言】
qq_53045580的博客
12-22 3599
欲发一封内容为 AABBCAB ……(共长 100 字符,其中:A 、 B 、 C 、 D 、 E 、 F 分别有 7 、 9 、 12 、 22 、 23、 27 个)的电报报文，实现哈夫曼编码和译码。
数据结构课程设计——哈夫曼编/译码器
随风飘荡的鱼儿的博客
05-22 3588
最初做这个程序的时候，让我觉得完成这次程序设计真的是有点困难，然后我查阅了课本，并在网上百度和在b站上看相关的知识视频，写这个程序的时候也参考了网上的设计流程。在基本要求达到后，可进行创新设计，如改善算法性能、友好的人机界面。利用已建好的哈夫曼树(如不在内存，则从文件hfmTree中读人)，对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。将已在内存中的哈夫曼树以直观的方式(树或凹入表形式)显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。
武汉大学信管专业期末复习系列——《数据结构》（python实现） 哈夫曼树及其应用
榕城候佳人的博客
12-04 707
武汉大学信管专业期末复习系列——《数据结构》（python实现） 哈夫曼树及其应用
哈夫曼树的java实现_java实现哈夫曼树
weixin_39765869的博客
03-02 242
哈夫曼译码,就是将输入的译码还原成对应的字符。 抽象的算法描述:将建立哈夫曼树、实现哈夫曼编码、哈夫曼译码都定义成 子函数的的形式, 然后在主函数中调用它们......数据结构课程设计设计题目: 哈夫曼树及其应用学 院:计算机科学与技术 专业:网络...用哈夫曼树实现图像压缩_数学_自然科学_专业资料。———用哈弗曼算法实现图像压缩...哈夫曼树课程设计 精品文档中南林业科技大学 课程设计报告 设...
【数据结构】哈夫曼树与哈夫曼编码的Python实现及应用
weixin_43643877的博客
06-16 2401
用python实现哈夫曼树与哈夫曼编码，并通过哈夫曼编码压缩核酸序列信息。
数据结构课程设计——哈夫曼树
06-07
在数据结构的学习中，哈夫曼树...总之，通过这个数据结构课程设计，你不仅能深入理解哈夫曼树的构建和应用，还能提升自己的编程能力，特别是处理数据压缩问题的能力。这将对你的未来IT职业生涯产生积极的影响。
应用数据结构课程设计(哈夫曼树).pdf
09-30
《应用数据结构课程设计——哈夫曼树》 哈夫曼树，又称最优二叉树，是数据结构中一种特殊类型的二叉树，主要用于数据压缩和编码。在本课程设计中，学生王涛被要求开发一个基于哈夫曼编码的编/译码系统，该系统适用...
数据结构课程设计_哈夫曼树.docx
07-12
《数据结构课程设计——哈夫曼树》 在计算机科学领域，数据结构是核心课程之一，它探讨如何高效地存储和检索数据。本课程设计旨在深入理解和应用数据结构中的哈夫曼树（Huffman Tree），这是一种特殊的二叉树，常...
数据结构课程设计实验报告哈夫曼树的应用.doc
09-22
数据结构课程设计实验报告主要关注的是哈夫曼树的应用，这是一种高效的数据压缩和编码方法，尤其在文本传输和数据存储中具有重要意义。哈夫曼树，又称为最优二叉树，是通过一种特殊的构建过程——哈夫曼编码，使得树...
HTML5大作业三农有机，农产品，农庄，农旅网站源码
xcLeigh
07-17 4145
HTML5大作业三农有机，农产品，农庄，农旅网站源码，农旅文化相关介绍网站，农产品网站，农庄网站，介绍农业相关的网站，农业网站大作业，毕业设计，功能点包含轮播图，图文处理，表单，表格，菜单，模块等各种风格都有，代码上手简单，代码独立，可以直接使用。也可直接预览效果。
大学生挑战杯-2.炒制即食板栗品质改良研究－罗爱民.ppt
07-26
大学生挑战杯-2.炒制即食板栗品质改良研究－罗爱民.ppt
基于C#开发的在线学习考试系统（源代码+数据库+各类文档）.zip
07-26
基于C#开发的在线学习考试系统（源代码+数据库+各类文档）.zip
基于JAVA公共资源模块的设计与开发(源代码+论文).rar
最新发布
07-26
基于JAVA公共资源模块的设计与开发(源代码+论文).rar
哈夫曼编译器数据结构课程设计
09-03
哈夫曼编译器数据结构课程设计是一项课程设计项目，旨在通过学习数据结构中的算法，特别是赫夫曼树的构建和赫夫曼编码的编码译码，来增强学生对数据结构的理解和应用能力。通过这个项目，学生可以提高他们独立设计程序和调试程序的能力。在设计和编写程序时，学生可能会遇到一些问题和错误，需要仔细检查代码中的小细节，并利用编译器的报错信息进行改进。如果学生无法找到错误所在，他们可以借阅网上资料，借鉴他人的经验来解决问题。通过完成这个课程设计项目，学生可以增强他们在编写程序和调试程序方面的能力，对他们今后的学习和职业发展都会有很大的帮助。哈夫曼编译器数据结构课程设计涉及到建立编码表和从叶子到根逆向求每个字符的哈夫曼编码的过程。在这个过程中，学生需要根据给定的哈夫曼树，从叶子节点开始逆向求编码，并将编码存储在哈夫曼编码表中。这个过程可以通过代码实现，具体的实现方法可以参考引用中的代码片段。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [《数据结构与算法》课程设计——哈夫曼编码](https://blog.csdn.net/orangemustared/article/details/118439191)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [《数据结构与算法》课程设计报告——赫夫曼编码/译码器](https://blog.csdn.net/weixin_43272781/article/details/103542257)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值