大二（上） 数据结构 哈夫曼编码

最新推荐文章于 2024-05-07 21:57:30 发布
最新推荐文章于 2024-05-07 21:57:30 发布
阅读量375 收藏 4
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43271844/article/details/83383998
版权 

#include<iostream>
#define MAX 200
using namespace std;
typedef char ElementType;
typedef double wghType;

typedef struct {
	ElementType Data;
	int w;
	int parent, lchild, rchild;
}HFMTNode;

//每个节点的编码
//code存储编码
//start存储编码是从code数组的第几个开始
//在编码过程中从叶子节点向根节点逆推
struct HFMTcode
{
	char code[MAX];
	int start;
};
//建立哈夫曼树
void CreateHFMTree(HFMTNode Ht[], int N)
{
	int i, k, lmin, rmin;
	int min1, min2;
	for (i = 1; i < 2 * N; i++)
	{
		min1 = min2 = MAX;
		lmin = rmin = -1;
		for (k = 1; k <= i - 1; k++)
			if (Ht[k].w == -1)
			{
				if (Ht[k].w < min1) {
					min2 = min1;
					rmin = lmin;
					min1 = Ht[k].w;
					rmin = k;
				}
				else if (Ht[k].w < min2)
				{
					min2 = Ht[k].w;
					rmin = k;
				}
			}
		Ht[lmin].parent = i;
		Ht[rmin].parent = i;
		Ht[i].w = Ht[lmin].w + Ht[rmin].w;
		Ht[i].lchild = lmin;
		Ht[i].rchild = rmin;
	}
}
//求每个节点的哈夫曼编码
void createHFMcode(HFMTNode *node, HFMTcode *hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		HFMTcode d;
		//哈夫曼树最大层数就是元素的个数
		d.start = n;
		int num = i;
		int father = node[num].parent;
		while (father != 0)
		{
			if (node[father].lchild == num)
				d.code[d.start--] = '0';
			else
				d.code[d.start--] = '1';
			num = father;
			father = node[num].parent;
		}
		hcode[i] = d;
	}
}
//打印每个节点的编码
void printHFMcode(HFMTNode * node, HFMTcode * hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << node[i].Data << " ：";
		for (int k = hcode[i].start + 1; k <= n; k++)
			cout << hcode[i].code[k];
		cout << endl;
	}
}


int  main(int argc, char* argv[])
{
	HFMTNode node[2 * MAX];
	HFMTcode hcd[MAX];

	cout << "请输入元素个数：" << endl;
	int n;
	cin >> n;
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << "输入第" << i << "个节点的值：" << endl;
		cin >> node[i].Data;
		cout << "输入它的权重：" << endl;
		cin >> node[i].w;
	}
	for (i = 1; i <= 2 * n - 1; i++)
	{
		node[i].parent = node[i].lchild = node[i].rchild = 0;
	}
	//建立哈夫曼树
	CreateHFMTree(node, n);
	//求每个节点的哈夫曼编码
	createHFMcode(node, hcd, n);
	//打印每个节点的编码
	cout << "输出每个节点的哈夫曼编码：" << endl;
	printHFMcode(node, hcd, n);
	
	cout << "请输入译码：" << endl;
	DeCoding(node, n);

	system("pause");
	return 0;
}

#include<iostream>
#include<stdio.h>
#define MAX 20
#define maxsize 100
using namespace std;
typedef char ElementType;

struct HFMnode
{
	ElementType data;
	int weight;
	int parent, lchild, rchild;
};

//每个节点的编码
//code存储编码
//start存储编码是从code数组的第几个开始
//在编码过程中从叶子节点向根节点逆推
struct HFMcode
{
	char code[MAX];
	int start;
};

//建立哈夫曼树
void createHFMtree(HFMnode *node, int n)
{
	int i;
	//m1,m2为当前还没用到的节点中权值最小和次小的权值
	int m1, m2;
	//l,r为每次构建一个父节点其左右儿子节点的序号
	int l, r;
	for (i = n + 1; i <= 2 * n - 1; i++)
	{
		m1 = m2 = 32767;
		l = r = 0;
		int k;
		for (k = 1; k <= i - 1; k++)
			if (node[k].parent == 0)
			{
				if (node[k].weight < m1)
				{
					m2 = m1;
					r = l;
					m1 = node[k].weight;
					l = k;
				}
				else if (node[k].weight < m2)
				{
					m2 = node[k].weight;
					r = k;
				}
			}
		node[i].weight = node[l].weight + node[r].weight;
		node[i].lchild = l;
		node[i].rchild = r;
		node[l].parent = i;
		node[r].parent = i;
	}
}

//求每个节点的哈夫曼编码
void createHFMcode(HFMnode *node, HFMcode *hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		HFMcode d;
		//哈夫曼树最大层数就是元素的个数
		d.start = n;
		int num = i;
		int father = node[num].parent;
		while (father != 0)
		{
			if (node[father].lchild == num)
				d.code[d.start--] = '0';
			else
				d.code[d.start--] = '1';
			num = father;
			father = node[num].parent;
		}
		hcode[i] = d;
	}
}

void HuffmanTranslateCoding(HFMnode* HT, int n, char* ch)
{
	//译码过程
	int m = 2 * n - 1;
	int i, j = 0;

	printf("After Translation:");
	while (ch[j] != '\0')                 //ch[]:你输入的要译码的0101010串
	{
		i = m;
		while (0 != HT[i].lchild && 0 != HT[i].rchild)   //从顶部找到最下面
		{
			if ('0' == ch[j])                //0 往左子树走
			{
				i = HT[i].lchild;
			}
			else                              //1 往右子树走
			{
				i = HT[i].rchild;
			}
			++j;                             //下一个路径
		}
		printf("%c", HT[i - 1].data);                  //打印出来
	}
	printf("\n");
}



//打印每个节点的编码
void printHFMcode(HFMnode * node, HFMcode * hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << node[i].data << " ：";
		for (int k = hcode[i].start + 1; k <= n; k++)
			cout << hcode[i].code[k];
		cout << endl;
	}
}

int main(int argc, char* argv[])
{
	HFMnode node[2 * MAX];
	HFMcode hcd[MAX];
	
	cout << "请输入元素个数：" << endl;
	int n;
	cin >> n;
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << "输入第" << i << "个节点的值：" << endl;
		cin >> node[i].data;
		cout << "输入它的权重：" << endl;
		cin >> node[i].weight;	
	}
	for (i = 1; i <= 2 * n - 1; i++)
	{
		node[i].parent = node[i].lchild = node[i].rchild = 0;
	}
	//建立哈夫曼树
	createHFMtree(node, n);
	//求每个节点的哈夫曼编码
	createHFMcode(node, hcd, n);
	//打印每个节点的编码
	cout << "输出每个节点的哈夫曼编码：" << endl;
	printHFMcode(node, hcd, n);

	cout << "哈夫曼译码：" << endl;
	char tran[100];
	gets_s(tran,10);
	HuffmanTranslateCoding(node, n, tran);

	system("pause");
	return 0;
}

正确版本

#include<iostream>
#include<stdio.h>
#define MAX 500
#define maxsize 1000
using namespace std;
typedef char ElementType;

struct HFMnode
{
	ElementType Data;
	int w;
	int parent, lchild, rchild;
};

//每个节点的编码
//code存储编码
//start存储编码是从code数组的第几个开始
//在编码过程中从叶子节点向根节点逆推
struct HFMcode
{
	char code[MAX];
	int start;
};

//建立哈夫曼树
void createHFMtree(HFMnode *node, int n)
{
	int i;
	//m1,m2为当前还没用到的节点中权值最小和次小的权值
	int min1, min2;
	//l,r为每次构建一个父节点其左右儿子节点的序号
	int l, r;
	for (i = n + 1; i <= 2 * n - 1; i++)
	{
		min1 = min2 = 32767;
		l = r = 0;
		int k;
		for (k = 1; k <= i - 1; k++)
			if (node[k].parent == 0)
			{
				if (node[k].w < min1)
				{
					min2 = min1;
					r = l;
					min1 = node[k].w;
					l = k;
				}
				else if (node[k].w < min2)
				{
					min2 = node[k].w;
					r = k;
				}
			}
		node[i].w = node[l].w + node[r].w;
		node[i].lchild = l;
		node[i].rchild = r;
		node[l].parent = i;
		node[r].parent = i;
	}
}

//求每个节点的哈夫曼编码
void createHFMcode(HFMnode *node, HFMcode *hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		HFMcode d;
		//哈夫曼树最大层数就是元素的个数
		d.start = n;
		int num = i;
		int father = node[num].parent;
		while (father != 0)
		{
			if (node[father].lchild == num)
				d.code[d.start--] = '0';
			else
				d.code[d.start--] = '1';
			num = father;
			father = node[num].parent;
		}
		hcode[i] = d;
	}
}

void DeCoding(HFMnode* HT, int n)
{
	int len, i, p;
	char str[1000];
	cout << "请输入相应的霍夫曼编码" << endl;
	cin >> str;
	len = strlen(str);
	cout << "译码的结果为:" << endl;
	for (i = 0; i < len;) {
		p = 2 * n - 1;
		while (HT[p].lchild != 0 && HT[p].rchild != 0) {
			if (str[i] == '0') p = HT[p].lchild;
			if (str[i] == '1') p = HT[p].rchild;
			i++;
		}
		cout << HT[p].Data;
	}
	cout << endl;
}

//打印每个节点的编码
void printHFMcode(HFMnode * node, HFMcode * hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << node[i].Data << " ：";
		for (int k = hcode[i].start + 1; k <= n; k++)
			cout << hcode[i].code[k];
		cout << endl;
	}
}

int main(int argc, char* argv[])
{
	HFMnode node[2 * MAX];
	HFMcode hcd[MAX];

	cout << "请输入元素个数：" << endl;
	int n;
	cin >> n;
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << "输入第" << i << "个节点的值与权重： " ;
		cin >> node[i].Data;
		cin >> node[i].w;
	}
	for (i = 1; i <= 2 * n - 1; i++)
	{
		node[i].parent = node[i].lchild = node[i].rchild = 0;
	}
	//建立哈夫曼树
	createHFMtree(node, n);
	//求每个节点的哈夫曼编码
	createHFMcode(node, hcd, n);
	//打印每个节点的编码
	cout << "输出每个节点的哈夫曼编码：" << endl;
	printHFMcode(node, hcd, n);
	//打印所得霍夫曼译码
	DeCoding(node, n);

	system("pause");
	return 0;
}

**

书本版本

**

#include<iostream>
#define MAX 200
using namespace std;
typedef char ElementType;

typedef struct {
	ElementType Data;
	int w;
	int parent, lchild, rchild;
}HFMTNode;

//每个节点的编码
//code存储编码
//start存储编码是从code数组的第几个开始
//在编码过程中从叶子节点向根节点逆推
struct HFMTcode
{
	char code[MAX];
	int start;
};
//建立哈夫曼树
void CreateHFMTree(HFMTNode Ht[], int N)
{
	int i, k, lmin, rmin;
	int min1, min2;
	for (i = 1; i < 2 * N; i++)
	{
		Ht[i].parent = Ht[i].lchild = Ht[i].rchild = 0;
		for (i = N + 1; i < 2*N; i++)
		{
			min1 = min2 = MAX;
			lmin = rmin = 0;
			for (k = 1; k <= i - 1; k++)
				if (Ht[k].parent == 0)
				{
					if (Ht[k].w < min1)
					{
						min2 = min1;
						rmin = lmin;
						min1 = Ht[k].w;
						lmin = k;
					}
					else if (Ht[k].w < min2)
					{
						min2 = Ht[k].w;
						rmin = k;
					}
				}
			Ht[lmin].parent = i;
			Ht[rmin].parent = i;
			Ht[i].w = Ht[lmin].w + Ht[rmin].w;
			Ht[i].lchild = lmin;
			Ht[i].rchild = rmin;
		}
	}
}

//求每个节点的哈夫曼编码
void createHFMcode(HFMTNode *node, HFMTcode *hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		HFMTcode d;
		//哈夫曼树最大层数就是元素的个数
		d.start = n;
		int num = i;
		int father = node[num].parent;
		while (father != 0)
		{
			if (node[father].lchild == num)
				d.code[d.start--] = '0';
			else
				d.code[d.start--] = '1';
			num = father;
			father = node[num].parent;
		}
		hcode[i] = d;
	}
}

void DeCoding(HFMTNode* HT, int n)
{
	int len, i, p;
	char str[1000];
	cout << "请输入相应的霍夫曼编码" << endl;
	cin >> str;
	len = strlen(str);
	cout << "译码的结果为:" << endl;
	for (i = 0; i < len;) {
		p = 2 * n - 1;
		while (HT[p].lchild != 0 && HT[p].rchild != 0) {
			if (str[i] == '0') p = HT[p].lchild;
			if (str[i] == '1') p = HT[p].rchild;
			i++;
		}
		cout << HT[p].Data;
	}
	cout << endl;
}

//打印每个节点的编码
void printHFMcode(HFMTNode * node, HFMTcode * hcode, int n)
{
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << node[i].Data << " ：";
		for (int k = hcode[i].start + 1; k <= n; k++)
			cout << hcode[i].code[k];
		cout << endl;
	}
}

int  main(int argc, char* argv[])
{
	HFMTNode node[2 * MAX];
	HFMTcode hcd[MAX];

	cout << "请输入元素个数：" << endl;
	int n;
	cin >> n;
	int i;
	for (i = 1; i <= n; i++)
	{
		cout << "输入第" << i << "个节点的值与权重： ";
		cin >> node[i].Data;
		cin >> node[i].w;
	}
	for (i = 1; i <= 2 * n - 1; i++)
	{
		node[i].parent = node[i].lchild = node[i].rchild = 0;
	}
	//建立哈夫曼树
	CreateHFMTree(node, n);
	//求每个节点的哈夫曼编码
	createHFMcode(node, hcd, n);
	//打印每个节点的编码
	cout << "输出每个节点的哈夫曼编码：" << endl;
	printHFMcode(node, hcd, n);

	DeCoding(node, n);

	system("pause");
	return 0;
}
Thorold's Deer
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法基础】哈夫曼树与哈夫曼编码(C++)
wayne_lee_lwc的博客
11-23 5741
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
利用哈夫曼编码进行通信可以大大提高信道的利用率
12-18
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端传来的数据进行译码。试为这样的信息收发站写一个哈夫曼码的编/译码系统。
哈夫曼树设计——利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通……
06-22
利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码，请设计这样的一个简单编/译码系统。
哈夫曼编码
dreamjay1997的博客
04-25 240
#include #include #define Max 10001 struct hfmnode{     int lfou;     int rfou;     int lchild;     int rchild;     int qnumber;     char node;     int xuan; }th[Max]; int n,i,j; struct S
哈夫曼树与哈夫曼编码
最新发布
Zhang_Qin123的博客
05-07 811
路径：从树中的一个节点到另一个节点之间的分支构成两个节点间的路径。节点的路径长度：两节点间路径的分支数（路径的个数）树的路径长度（TL）：从根节点到树中。路径长度：节点A到A，B，C，D，E，F的路径长度分别为0，1，1，2，2，2树的路径长度（TL）：节点A到树中每个节点的路径之和　TL=0+1+1+2+2+2=8权（权重）：将树中的节点赋值（具体实际意义与场合有关）。节点的带权路径长度：从根节点到该节点之间的路径长度与节点上权的乘积。树的带权路径长度（WPL）：树中。
哈夫曼树
热门推荐
D_Double's Journey
03-11 15万+
一、哈夫曼树的概念和定义   什么是哈夫曼树？ 让我们先举一个例子。 判定树：         在很多问题的处理过程中，需要进行大量的条件判断，这些判断结构的设计直接影响着程序的执行效率。例如，编制一个程序，将百分制转换成五个等级输出。大家可能认为这个程序很简单，并且很快就可以用下列形式编写出来：   if(score<60) cout<<"Bad"<<endl; e
数据结构课设基于C++的哈夫曼数据结构实现的编码译码程序源码+代码注释+实验报告.zip
07-20
这是大二的数据结构课程设计,基于C/C++,包括通讯录,哈夫曼 赫夫曼编译码器开发 项目要求： （1）系统功能：从文件或键盘读入一串电文字符，实现赫夫曼编码和译码。 （2）密码文件以文件的形式进行存放。 项目目的：...
哈夫曼编码.zip
06-01
在大二的计算机科学与技术专业课程中，数据结构和C语言是基础课程，哈夫曼编码作为数据结构中的一个重要概念，通常会作为课程作业的一部分，让学生通过编程实践来理解和掌握。在完成这样的作业时，学生需要编写C语言...
基于C和C++实现通讯录-哈夫曼编码-交通咨询系统-图书管理系统(含实验报告)数据结构课程设计.zip
06-02
基于C和C++实现通讯录_哈夫曼编码_交通咨询系统_图书管理系统(含实验报告)数据结构课程设计.zip 【资源说明】 这是大二的数据结构课程设计,基于C/C++,包括通讯录,哈夫曼,交通图以及图书管理系统 具体要求如下: 学生...
南航 数据结构 课程设计 大二.zip
05-07
【标题】南航数据结构课程设计大二.zip的解析与详解 在计算机科学领域，数据结构是编程的基础，它涉及到如何高效地存储和组织数据，以便进行有效的计算和操作。本课程设计集涵盖了一系列的数据结构应用实例，旨在...
二叉树的基本操作及哈夫曼编码译码的实现（实验二）
xx_ii
04-02 3536
实验目的： 1.掌握二叉树的二叉链表存储表示及遍历操作实现方法。 //完成二叉树的创建，先序遍历，中序遍历，后续遍历 #include&lt;iostream&gt; #include&lt;cstring&gt; using namespace std; typedef char ElementType; //二叉树二叉链表结点结构定义： typedef struct node{ ...
哈夫曼 编码解码
文轩
11-07 455
给定字符串， 建造哈夫曼树，并将字符串转为哈夫曼编码 1. 字符串 2. 字符权值 3. 哈夫曼树建立 4. 字符所对应的哈夫曼编码 5. 字符串编码结果 6. JS源码 ： /** * @author 轩 http://wx0725.top * 如果a.val存在，定义类属性a.val()返回左右和 */ HAHA.prototype.val = function() { return (this.left.type ? this.left.val() : this.left.value
哈夫曼树初了解
lxiao428的博客
01-03 273
内容来自百度百科和百度经验。 怎么画出哈弗曼树： 哈夫曼树，类似于算法中的二叉树，说白了哈夫曼树就是一种二叉树，只是是一种最优二叉树。我们准备一组数以 1，7，3，4，9，8为例子吧，请忽略12 第一步，我们对这一组数字进行排序。规则是从小到大排列。排列之后的顺序是 1，3，4，7，8，9，请忽略12
哈夫曼树的概念和代码实现
长期更新自学笔记
04-18 1777
文章目录一、 基本概念二、构造哈夫曼树三、哈夫曼树的基本性质四、哈夫曼编码五、哈夫曼解码 一、 基本概念 结点的权： 有某种现实含义的数值 结点的带权路径长度： 从结点的根到该结点的路径长度与该结点权值的乘积 树的带权路径长度： 树上所有叶结点的带权路径长度之和（wpl=∑i=1nwiliwpl=\sum\limits_{i=1}^{n}w_il_iwpl=i=1∑n​wi​li​） 哈夫曼树： 在含有nnn个带权叶结点的二叉树中，wplwplwpl 最小 的二叉树称为哈夫曼树，也称最优二叉树（给定叶子结
【数据结构X.11】代码实现 哈夫曼树的创建，建立，构造，实现哈夫曼编码
清凌的博客
12-13 1961
哈夫曼树的各种语言java，python，c++ 代码实现哈夫曼树的创建，建立，构造，实现哈夫曼编码，实现思路和要点： 抓住哈夫曼树的性质，每轮选出2个权值最小的点进行构造树。 抓住哈夫曼编码的性质，从根出发，向左标0，向右标1. 哈夫曼树的构造思路： 已知某系统在通信联络中只可能出现8种字符，其概率分别为0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11 试着设计赫夫曼编码。 假设权w=（5，29，7，8，14，23，3，11），n=8，则m=15，按照上述算法构造一颗哈夫曼树
哈夫曼算法
qq_51699436的博客
12-22 2620
哈夫曼算法 哈夫曼算法的一般步骤如下: 1.初始化：由给定的 个权值构造nnn棵只有一个根节点的二叉树，得到一个二叉树集合FFF 。 2.选取与合并：从二叉树集合FFF中选取根节点权值 最小的两棵 二叉树分别作为左右子树构造一棵新的二叉树，这棵新二叉树的根节点的权值为其左、右子树根结点的权值和。 3.删除与加入：从FFF中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到FFF中。 4.重复 2、3 步，当集合中只剩下一棵二叉树时，这棵二叉树就是霍夫曼树。 代码 #include<stdio.
数据结构：哈夫曼编码与二叉树解析
"哈夫曼编码的生成-数据结构中的树" 在数据结构中，树是一种重要的抽象数据类型，用于表示具有层次关系的数据元素。本话题主要关注哈夫曼编码的生成，这是一种基于树的编码方法，特别适用于数据压缩。 哈夫曼编码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值