数据结构实验三：哈夫曼编/译码器

最新推荐文章于 2023-07-06 14:32:43 发布
最新推荐文章于 2023-07-06 14:32:43 发布
阅读量3k 收藏 51
点赞数 3
文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JackyJiang1/article/details/122532230
版权

数据结构实验三：哈夫曼编/译码器

实验题目描述

1.基本要求

利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道〉，每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。

2.参考

利用教科书《数据结构》（紫书）例6-2 中的数据调试程序。

3.实验测试用例

用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE ”。
字符集和频度

实验过程

1.开发环境描述

1.开发环境：Visual Studio 2019
2.操作系统：win10

2.题目分析及解题思路

  • 问题抽象：
    由于字符集权值已经给出，故可以直接由字符集权值建立哈夫曼树，再由已经建成字符集权值生成每个字符的编码；
  • 问题解决思路：
    ①从文件中导入字符集权值，存入哈夫曼树的叶子结点中；
    ②遍历每个叶子结点。在所有结点中寻找最小的两个结点，两个结点生成一个根节点，然后不断重复这个操作，直到最后生成一个完整的哈夫曼树；
    ③设定哈夫曼树的左孩子是“0”，右孩子为“1”，从根节点开始遍历，遍历到叶子结点，从中可以得出每一个叶子结点的哈夫曼编码；
    ④由用户输入的字符串得到编码，或是从用户输入的编码得到字符串，实现一个双向的编码、译码；
    ⑤本人补充了基于mqtt协议与单片机的哈夫曼编码译码系统设计，实现了两台电脑通过mqtt这座“桥梁”实现双向编码译码
  • 确定输入输出:
    Input:
    ①用户输入的对应功能的选择编号（1打印字符集的权值以及字符集的编码；2. 将字符串翻译为编码；3. 将编码翻译为字符串）
    ②用户输入模式（手动输入或由文件导入）
    ③用户输入的待编码的字符串 or 用户输入的待翻译代码
    Output：
    ①打印字符集的权值以及字符集的编码
    ②编码 or 译码

3.实验代码

①处理交互的Interaction.h文件

#ifndef INTERACTION_H
#define INTERACTION_H

void Initialize();             //初始化
int Intercommand();            //输入选择模式
int Get_choose();              //得到y or n
void Is_refresh();            //检查页面是否更新
int Get_int();                //我编写的判断 输入是否为整形的函数，
char* Get_Capital_letter();   //得到大写字母
char* Get_01();               //得到01码

#endif // !INTERACTION_H

处理交互的Interaction.cpp文件

#include"Interaction.h"
#include<iostream>
#include<stdio.h>
#include<conio.h> 
#include<math.h>
#include<string>
using namespace std;
#define backColor 7
#define textColor 1

enum Color
{
	black, blue, green, lakeBlue, red, purple, yellow, white, gray
};

void Initialize()
{
	system("cls");
	//设置背景颜色
	char command[9] = "color 07";		//默认颜色	
	command[6] = '0' + backColor;		//将backColor变量改为字符型(背景颜色设置为7，为白色） 
	command[7] = '0' + textColor;		//将textColor变量改为字符型 （背景颜色设置为1，为蓝色）
	system(command);				    //调用系统函数 
	//设置菜单
	printf("                        **************哈夫曼树编码器与译码器***********\n");
	printf("                        |    \t0. 退出                               |\n");
	printf("                        |    \t1. 打印字符集的权值以及字符集的编码   |\n");
	printf("                        |    \t2. 将字符串翻译为编码                 |\n");
	printf("                        |    \t3. 将编码翻译为字符串                 |\n");
	printf("                        ***********************************************\n");
	
}

int Intercommand()
{
	cout << "请输入您的选择:";
	int input;
	while (1)
	{
		int n = Get_int();
		if (n >= 0 && n < 4)
		{
			input = n;
			break;
		}
			
		cout<<"输入错误，请重输：";
	}
	
	return input;
}

int Get_choose()
{
	char ch[21] = { 0 };
	int flag;
	int i = 0;
	while (1)
	{
		fflush(stdin);
		scanf_s("%s", ch, 20);
		if (ch[i] == 'y' || ch[i] == 'Y')
		{
			flag = 1;
			break;
		}
		else if (ch[i] == 'n' || ch[i] == 'N')
		{
			flag = 0;
			break;
		}
		else {
			cout << "输入错误，请重新输入" << endl;
		}
	}
	return flag;
}

char* Get_Capital_letter()
{
	char s[100] ;
	int i ;
	cin.get();
label2:
	i = 0;
	fflush(stdin);
	gets_s(s);
	while (s[i])
	{
		if (s[i] >= 65 && s[i] <= 90)
			i++;
		else if (s[i] == 32)
		{
			s[i++] = 32;
		}
		else if(s[i]==13){
			break;
		}
		else {
			cout << "您输入非大写字母的字符，无法进行翻译,请重新输入：" << endl;
			goto label2;
		}
		
	}
	s[i] = '\0';
	return s;
}

char* Get_01()
{
	char s[300] = { 0 };
	int i;
label3:
	i = 0;
	fflush(stdin);
	scanf_s("%s", s, 300);
	while (s[i])
	{
		if (s[i] =='0'||s[i]=='1')
			i++;
		else if (s[i] == 13) {
			break;
		}
		else {
			cout << "您输入非01的字符，无法进行翻译,请重新输入：" << endl;
			goto label3;
		}

	}
	s[i] = '\0';
	return s;
}

void Is_refresh()
{
	printf("\n");
	cout << "----------------------------------------------------"<<endl;
	cout << "输入任意字符完成查看，回到菜单页面:" << endl;
	_getch();
}

int Get_int()
{
	int num = 0,i=0;     //int
	char ch[11] = { 0 }; 
label1:
	num = 0;
	scanf_s("%s", ch,10);
	i = 0;
	if (ch[0] == 45 || ch[0] == 43)  //"+""-"
	{
		i++;
	}
	while (ch[i])
	{
		if (ch[i] < '0' || ch[i]>'9')
		{
			cout << "输入错误，请输入数字:" << endl;
			goto label1;
		}
		else {
			num = num * 10 + (int)ch[i] - 48;
		}
		i++;

	}
	if (ch[0] == 45)
	{
		return -num;
	}
	else
	{
		return num;
	}
}

② 处理文件读取的file.h

#ifndef FILE_H
#define FILE_H

#include<fstream>
#include<string>
#include"Huffman.h"

using namespace std;

void load_weightdata_file(HTNode hnode[]);//加载每个字符的权值
char* load_code();  //载入待翻译的代码
char* load_text();  //载入待编码的文本

#endif // !FILE_H

处理文件读取的file.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <fstream>
#include <string>
#include <vector>
#include <windows.h>
#include"file.h"
#include"Huffman.h"

using namespace std;
#define N  50
int g_flag = 0;

//用该函数读取每个字符对应的权值
void load_weightdata_file(HTNode hnode[])
{
	FILE* fp;
	int i = 0;
	fp = fopen("weightdata.txt", "r");
	if (fp == NULL)
	{
		cout<<"打开文件失败";
	}
	while (!feof(fp))
	{
		fscanf(fp, "%c", &(hnode[i].data));
		fscanf(fp, "%d", &(hnode[i].weight));
		fseek(fp, 2, SEEK_CUR);
		i++;
		if (i == N - 2)
			break;
	}
	g_flag = 1;
	fclose(fp);
}

char* load_code() {
	ifstream in("code.txt");
	char buffer[256];
	if (!in.is_open()) {
		cout << "加载文件错误" << endl;
		return NULL;
	}
	cout << "载入编码文件" << endl;
	in.getline(buffer, 200, ' ');
	return buffer;
}

char* load_text()
{
	ifstream in("text.txt");
	char buffer[256]; 
	if (!in.is_open()) {
		cout << "加载文件错误" << endl;
		return NULL;
	}
	cout << "载入待编码字段" << endl;
	in.getline(buffer, 100);

	return buffer;
}


//用该函数输出各个字符的编码 字符 对应编码
int Print_HuffMan_file()
{
	FILE* fp;
	char data[50], c;
	int d;
	fp = fopen("Huffman.txt", "r");
	if (fp == NULL )
	{
		printf("打开文件哈夫曼编码错误。\n");
		return -1;
	}
	while (1)
	{
		fscanf(fp, "%c%d%s", &c, &d, data);
		if (feof(fp))
			break;
		printf("%c\t%d\t%s\n", c, d, data);
		fseek(fp, 2, SEEK_CUR);
	}
	fclose(fp);
}

③处理哈夫曼编码与译码的Huffman.h

#ifndef HUFFMAN_H
#define HUFFMAN_H

#include<string>
#define N 50		/*叶子结点数*/
#define M 2*N-1		/*树中结点总数*/
using namespace std;

/*实现思路：
一.先由存入文件中的各字符的频率计算出各字符的哈夫曼树编码，由此得到哈夫曼结点
哈弗曼结点包含了下列信息：1.该结点对应的编码（存入到HCode中的cd中） 2.权重（就是频率）
						  3.父母结点，左子结点，右子结点
二.输入字符串，由于已经计算了每个字符对应的编码，故直接把每个字符翻译出来就好了*/

typedef struct {
	char data;           //定义结点值,此处为ABCD.....
	unsigned int weight; //定义每个节点的权重
	unsigned int parent, lchild, rchild;
}HTNode,*HuffmanTree;

typedef struct {
	char cd[N];
	int start;
}HCode; //定义
void Print_weightdata(HTNode hnode[],int n=27);     //输出权值
void CreateHT(HTNode ht[], int n);		           //创建哈夫曼树,将树结点数组转换为树
void CreateHCode(HTNode ht[], HCode hcd[], int n); //创建哈夫曼树编码
void DispHCode(HTNode ht[], HCode hcd[], int n);    //打印字符集编码
void Encode(char* s, HTNode ht[], HCode hcd[], int n);//实现编码并打印
void DeCode(string s, int n, HTNode h[]);//实现译码并打印

#endif // !HUFFMAN_H

处理哈夫曼编码与译码的Huffman.cpp

#include"Huffman.h"
#include<iostream>
#include<stdlib.h>

using namespace std;

void CreateHT(HTNode ht[], int n)
{
	int i, j, k, lnode, rnode;
	double min1, min2;

	for (int i = 0; i < 2 * n - 1; i++)
		ht[i].parent = ht[i].lchild = ht[i].rchild = -1; //将整根树进行一个初始化

	for (i = n; i < 2 * n - 1; i++) {
		min1 = min2 = 10000;
		lnode = rnode = -1;
		for (k = 0; k < i; k++) 
		{
			//循环，找到最小的结点
			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[i].weight = ht[lnode].weight + ht[rnode].weight;
		ht[i].lchild = lnode; ht[i].rchild = rnode;
		ht[lnode].parent = i; ht[rnode].parent = i;
	}  //完成树的创建
}

void CreateHCode(HTNode ht[], HCode hcd[], int n) {	 /*创建哈夫曼编码*/
	int i, f, c;
	HCode hc;
	for (i = 0; i < n; i++) {
		hc.start = n; c = i;
		f = ht[i].parent;
		while (f != -1) {                         //如果不是根节点,从当前结点循环，直到编码完成
			if (ht[f].lchild == c)               //如果为该节点的左孩子
				hc.cd[hc.start--] = '0';
			else
				hc.cd[hc.start--] = '1';
			c = f; f = ht[f].parent;
		}
		hc.start++;
		hcd[i] = hc;
	}
}

void DispHCode(HTNode ht[], HCode hcd[], int n) {	/*显示各个字符的哈夫曼编码*/
	int i, k;
	int sum = 0, m = 0;
	cout << "该字符集的哈夫曼编码如下: " << endl;
	for (i = 0; i < n; i++) {
		cout << ht[i].data << " ";
		for (k = hcd[i].start; k <= n; k++) {
			cout << hcd[i].cd[k];
		}
		printf("\n");
	}
}


/*将字符串进行编码*/
void Encode(char* s, HTNode ht[], HCode hcd[], int n) { /*显示字符串s的哈夫曼编码*/
	int i, j, k;
	for (i = 0; s[i] != '\0'; i++)
		cout << s[i];
	cout << "的哈夫曼编码是: " << endl;
	i = j = 0;
	while (s[j] != '\0') {
		if (s[j] == ht[i].data) {
			for (k = hcd[i].start; k <= n; k++)
				cout << hcd[i].cd[k];
			j++;
			i = 0;
		}
		else
			i++;
	}
	cout << endl;
}

/*将编码进行翻译，翻译为字符串*/
void  DeCode(string s, int n, HTNode h[])
{
	int i = 0, j = 0, lchild = 2 * n - 2, rchild = 2 * n - 2;
	while (s[i] != '\0') {
		if (s[i] == '0') {
			lchild = h[lchild].lchild;
			rchild = j = lchild;
		}
		if (s[i] == '1') {
			rchild = h[rchild].rchild;
			lchild = j = rchild;
		}
		if (h[lchild].lchild == -1 && h[rchild].rchild == -1) {
			cout << h[j].data;
			lchild = rchild = 2 * n - 2;
			j = 0;
		}
		i++;
	}
}

void Print_weightdata(HTNode hnode[],int n)
{
	int i;
	cout << "该字符集的权值如下: " << endl;
	for (i = 0; i < n; i++) {
		cout << hnode[i].data << " ";
		cout << hnode[i].weight << endl;
	}
}

④实现逻辑功能的源.cpp

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<conio.h>
#include"Huffman.h"
#include"Interaction.h"
#include"file.h"
using namespace std;

#define N 50		/*叶子结点数*/
#define M 2*N-1		/*树中结点总数*/

int n = 27;
int main() {
	int choose ; //选择变量
	HTNode ht[M];
	HCode hcd[N];//定义哈夫曼树结点和哈夫曼编码

	load_weightdata_file(ht);
	CreateHT(ht, n);
	CreateHCode(ht, hcd, n);

	char s[100] = { 0 };
	char input_code[300] = { 0 };
	int y_or_n = 0;
	while (1)
	{
		Initialize();
		choose = Intercommand();
		switch (choose)
		{
		case 0:
			exit(0);
		case 1:
			/*进行权重输出*/
			Print_weightdata(ht);
		    //进行编码输出
			DispHCode(ht, hcd, n);
			//检测用户是否查看完毕并进行页面的刷新
			Is_refresh();
			break;
		case 2:
			/*文件导入或者手动输入字符串*/
			cout << "请问您要手动输入字符串还是通过文件导入需要编码的字符串,文件输入请按y，手动输入请按n:";
			fflush(stdin);
			getchar();
			y_or_n = Get_choose();
			if (y_or_n == 0)
			{
				
				cout << "请输入字符串：" << endl;
				fflush(stdin); 
				strcpy_s(s, Get_Capital_letter());
				//gets_s(s);
				Encode(s, ht, hcd, n);
			}
			else if (y_or_n == 1)
			{
				strcpy_s(s, load_text());
				Encode(s, ht, hcd, n);
			}
			/*检测用户是否查看完毕并进行页面的刷新*/
			Is_refresh();
			break;

		case 3:
			/*文件导入或手动输入编码*/
			cout << "请问您要手动输入编码还是通过文件导入需要译码的编码,文件输入请按y，手动输入请按n:";
			fflush(stdin);
			getchar();
			y_or_n = Get_choose();
			if (y_or_n == 0)
			{
				
				cout << "请输入编码：" << endl;
				fflush(stdin);
				strcpy_s(input_code, Get_01());
				DeCode(input_code, n, ht);
			}
			else if (y_or_n == 1)
			{
				strcpy_s(input_code, load_code());
				DeCode(input_code, n,ht);
			}
			/*检测用户是否查看完毕并进行页面的刷新*/
			Is_refresh();
			break;
		}
	}

	return 0;
}

4.文件

  • Huffman.txt内容
     111
    A 1010
    B 100000
    C 00000
    D 10110
    E 010
    F 110011
    G 100001
    H 0001
    I 0110
    J 1100001000
    K 11000011
    I 10111
    M 110010
    N 0111
    O 1001
    P 100010
    Q 1100001001
    R 0010
    S 0011
    T 1101
    U 00001
    V 1100000
    W 110001
    X 1100001010
    Y 100011
    Z 1100001011
  • weightdata.txt内容
     186
    A 64
    B 13
    C 22
    D 32
    E 103
    F 21
    G 15
    H 47
    I 57
    J 1
    K 5
    L 32
    M 20
    N 57
    O 63
    P 15
    Q 1
    R 48
    S 51
    T 80
    U 23
    V 8
    W 18
    X 1
    Y 16
    Z 1
  • text.txt内容
    THIS IS MY FAVORITE PROGRAM

联系我

如果对代码有改进想法的或者需要源代码的，可联1274669808@qq.com

jzndd
关注
哈弗曼树的建立和编码实现
11-17
用下表给出的字符集和频度的实际统计数据建立哈夫曼树并显示出来，实现以下报文的编码 “THIS PROGRAM IS MY FAVORITE”。 选作：对哈夫曼生成的编码进行译码。
哈夫曼树以其编码解码
weixin_44980072的博客
11-14 1122
哈夫曼树以其编码解码 本人大二学渣，写的不好的地方大神勿喷！ 哈夫曼树以其编码解码要求： 1.从终端读入字符集大小为n（即字符的个数），逐一输入n个字符和相应的n个权值（即字符出现的频度），建立哈夫曼树，进行编码并且输出。 将它存于文件hfmtree中（选做）。 2.利用已建好的哈夫曼编码文件hfmtree，对键盘输入的正文进行译码。输出字符正文，再输出该文的二进制码。 [测试数据] 用下表中给出...
数据结构之哈夫曼编译码器（C语言版）
热门推荐
不点儿的博客
07-08 2万+
数据结构之哈夫曼编译码器的实现（C语言） 一枚学习编程的小白，前段时间在看数据结构，就把学到的整理一下下，有错误的地方希望大神可以指点嘻嘻嘻~ 需求分析：一个完整的系统应具有以下功能 初始化： 从终端输入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存入文件hfmtree文件中。 编码: 利用已建立的哈夫曼树，对文件tobetran中的正文进行编码，然后将结果存入codefile中。 译码: 利用已建好的哈夫曼树将文件codefile中的代码进行译码，结果存入文件textfile中 。 印代
数据结构哈夫曼树（VC6.0程序）
12-28
1） 初始化（Initialzation）。利用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并将它存于文件hfmTree中； 2） 编码（EnCoding）。利用已建好的哈夫曼树（若不在内存中，则从文件hfmTree中读入），对以下报文进行编码，结果存入文件CodeFile中； 报文内容：THIS PROGRAM IS MY FAVORITE 3） 译码（Decoding）。利用已建好的哈夫曼树，对文件CodeFile中编码后的报文进行解码，结果存入文件Textfile中； 4） 输出（Output）。输出字符集中每个字符的哈夫曼编码；输出原始报文，及其编码文件CodeFile和解码文件Textfile的内容。
数据结构课设
Xzq210509的博客
02-26 799
Huffman编／译码器 【问题描述】 利用Huffman编码进行通信可以大大提高信道利用率．缩短信息传输时间，降低传输成本，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编／译码系统。试为这样的信息收发站写一个Huffman码的编／译码系统。 【基本要求】 一个完整的系统应具有以下功能： （l）I：初始化。从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTre
数据结构课程设计--哈夫曼编/译码器
01-12
在这个数据结构课程设计中，我们将探讨哈夫曼编码器和解码器的实现，以及它们在实际应用中的工作原理。 哈夫曼编码的基本思想是利用字符出现的频率来构建一棵特殊的二叉树——哈夫曼树（Huffman Tree）。在哈夫曼树...
数据结构课程设计哈夫曼树编译码器报告.doc
06-15
**哈夫曼编码原理** ...哈夫曼编码器的设计和实现，不仅锻炼了编程能力，还深化了对数据结构的理解，特别是二叉树和优先队列的应用。通过这个课程设计，学生能够体验到理论知识与实践操作的结合，提升问题解决能力。
数据结构实验二哈夫曼树及哈夫曼编码译码的实现
06-07
哈夫曼树及哈夫曼编码译码的实现 哈夫曼树是一种特殊的二叉树，它的每个节点的权重是其所有子节点...通过本实验，我们掌握了哈夫曼树的建立和哈夫曼编码的算法，并了解了哈夫曼树在数据压缩、编码、译码等领域的应用。
哈夫曼编码/译码器
11-27
哈夫曼编码是一种高效的数据压缩方法，常用于文本、图像等多种数据类型的压缩。...云南大学数据结构课程的第五次实验通过实践操作，让学生深入理解哈夫曼编码的原理和应用，有助于提升学生的算法分析与编程能力。
数据结构实验三_哈夫曼编解码器.pdf
11-12
实验内容是构建一个哈夫曼编解码器，包括初始化、建立编码表、编码、译码、打印（选作）和分析压缩效果等步骤。 哈夫曼树，又称为最优二叉树，是一种特殊的二叉树，它的特点在于带权路径长度最短，即从根节点到每个...
信号处理多媒体通信matlab哈夫曼编码译码
06-24
利用哈夫曼编码进行通信可以大大提高信道的利用率，缩短信息传输的时间，降低传输成本。编程实现哈夫曼（Huffman）编码与译码。matlab代码和报告文档。
基于C++文件的哈夫曼编码与解码.zip
06-21
资源包含文件：设计报告word+源码及可执行exe文件 准备一个字符文件，要求： 统计该文件中各种字符的频率 对各字符进行 Huffman 编码，显示每个字符的编码 以及将该文件翻译成 Huffman 编码文件 再将 Huffman 编码文件翻译成源文件 显示每个字符以一个字节进行二进制编码后的编码文件 实现步骤可分为： 统计被编码文件中个字符出现的频数，即统计权重 根据权重，构造哈夫曼树，进行哈夫曼编码 读取文件进行二进制编码 读取文件，将每个字符匹配哈夫曼编码，写入新文件，即完成编码 读取编码文件，根据哈夫曼编码进行解码，并写入新文件 对比二进制编码和哈夫曼编码后的文件字节大小，并计算压缩率 通过编写利用哈夫曼算法实现的文件编码解码小工具，可加深对哈夫曼算法的理解，以及编码的熟练度。本人的小工具仅针对英文大小字母及 ' '\n' ' ' 字符针对性的进行了哈夫曼编码，若想实现中文及各种支持语言的编码，可在此代码基础上，进行优化。 详细介绍参考：https://biyezuopin.blog.csdn.net/article/details/122588072
哈夫曼树设计——利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通……
06-22
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码，请设计这样的一个简单编/译码系统。
数据结构实验——哈夫曼编码
Anffen的博客
01-17 8634
目录 问题描述 基本要求 问题分析 实验代码 运行结果 实验总结 问题描述 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发编写一个哈夫曼码的编/译码系统。 基本要求 （1）接收原始数据（电文）：从终端输入电文（电文为一个字符串，假设仅由26个小写英文字母构成）。 （
哈夫曼树的构建及应用
weixin_30496431的博客
02-17 1716
哈夫曼树，又称最优树，是一类带权路径最短的树。 哈夫曼树和哈夫曼的存储表示： typedef struct{ unsigned int weight; unsigned int parent,lchild,rchild; }HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树 typedef char **HuffmanCode;//动态分配数组存储...
C/C++数据结构与算法课程设计[2023-07-03]
最新发布
code helper
07-06 3203
数据结构与算法课程设计一、课程设计的目的、要求和任务本课程设计是为了配合《数据结构与算法》课程的开设，通过设计完整的程序，使学生掌握数据结构的应用、算法的编写等基本方法。1.课程的目的（1）使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。（2）使学生掌握软件设计的基本内容和设计方法，并培养学生进行规范化软件设计的能力。（3）使学生掌握使用各种计算机资料和有关参考资料，提高学生进行程序设计的基本能力；
哈夫曼编/译码系统的设计与实现
浅笑醉红楼
03-15 2434
【实验目的】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（解码）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站设计一个哈夫曼编译码系统。 【实验要求】 （1）从数据文件DataFile.dat中读入字符及每个字符的权值，建立哈夫曼树HuffTree； （2）编码（EnCoding）。用已建好的哈夫曼树，对文件ToBeTran.dat中的文
数据结构实训——哈夫曼编码/译码器
Tang7O的博客
12-25 7003
哈夫曼(Huffman)编/译码器（限1人完成） 【问题描述】 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。首先输入一段包含27个字符（包含空格）...
《数据结构课程设计：哈夫曼编码/译码系统的设计与实践》
实验原理清晰明了，通过这次实验，学生可以提高自己的问题分析和解决能力，进一步巩固数据结构各种原理与方法，并且熟悉掌握一门计算机语言，可以进行数据算法的设计，同时也可以更深入地理解哈夫曼编码译码系统的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值