【数据结构】哈夫曼树的C++面向对象实现

最新推荐文章于 2024-09-17 10:14:05 发布
最新推荐文章于 2024-09-17 10:14:05 发布
阅读量1k 收藏 3
点赞数 2
分类专栏： C++ 文章标签： c++ 数据结构 算法 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgsdlr/article/details/121252435
版权

哈夫曼树 最优二叉树 带权路径长度 C++实现 数据结构
关键词由CSDN通过智能技术生成

“哈夫曼树”介绍

给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)

特点

哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近

相关术语

1.路径和路径长度

在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路径长度为L-1

2.结点的权及带权路径长度

若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积

3.树的带权路径长度

树的带权路径长度规定为所有叶子结点的带权路径长度之和

前期准备

结构体——存储结点信息

struct ElemType{
    int weight;
    int parent,lchild,rchild;
};

类的声明

class HuffmanTree
{
public:
	HuffmanTree(int w[ ], int n);
	HuffmanTree( );
	void Print( );
private:
	ElemType *huffTree;						//数组用于存储哈夫曼树
	int num;								//统计叶子结点数量
	void Select(int n, int &i1, int &i2);	//选取叶子函数
};

类的实现

成员函数

1.构造函数

使用数组存储结点数据。
构造思路：
(1)对结构体数组初始化（包括建立空间、标记父子关系）并将叶子结点 w1、w2、…，wn的权值抄入结构体数组中；
(2) 选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；并对新结点和子树进行匹配；
(3)将新树加入数组中（放入叶子结点后面的位置）；
(4)重复(2)、(3)步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。

含n个叶子结点的二叉树经过合并后，分支结点共（n-1）个，哈夫曼树的结点数为（2n-1）.

HuffmanTree::HuffmanTree(int w[ ], int n){
    //构造哈夫曼树
    num=n;
    huffTree=new ElemType[2*n-1];		//建立存储数组 
    int i,k,i1,i2;                      //i为叶子结点循环变量，k标记求和后的节点，i1、i2标记最小次小元素位置
    for(int i=0;i<2*num-1;i++){           //初始化，将parent、lchild、rchild均置为-1
    huffTree[i].parent=-1;
    huffTree[i].lchild=huffTree[i].rchild=-1;
    }
    
    for(int i=0;i<num;i++){
        huffTree[i].weight=w[i];	//传叶子结点 
    }

    for(int k=num;k<2*num-1;k++){   //k从数组最后开始，对应权值存储权重数组内最小的俩元素下标

        Select( k ,i1,i2 );
        huffTree[k].weight = huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent= k; huffTree[i2].parent=k;
        huffTree[k].lchild = i1;huffTree[k].rchild = i2;
    }
}
2.选取叶子函数Select

遍历叶子结点，对最小和次小的叶子结点合并，为建哈夫曼树做准备

程序声明时，对i1、i2使用引用参数，使得i1、i2的值都可返回到调用位置，并参与调用位置后面的运算。

程序执行前，i1、i2为异常值，函数执行时，从第一个不存在父节点的叶子结点（未进行父子配对的结点）开始，依次找寻最小和次小结点，更新i1、i2的数值。

P.S.程序执行过程，大家可以自行列表模拟，代码不难理解~~

上代码：

void HuffmanTree::Select(int n, int &i1, int &i2)
{
	int temp;
	int i = 0;
	for ( ; i < n; i++)
		if (huffTree[i].parent == -1) {i1 = i; break;}
	for (i = i + 1; i < n; i++)
		if (huffTree[i].parent == -1) {i2 = i;break;}
	if (huffTree[i1].weight > huffTree[i2].weight)  //左边大于右边
	{
		temp = i1; i1 = i2;i2 = temp;               //小的是左孩子、大的是右孩子
	}
	//从i2的下一位置开始遍历，继续找小的元素，更新i1、i2的值
		for (i = i + 1; i < n; i++)
	{
		if (huffTree[i].parent == -1)
		{
			if (huffTree[i].weight < huffTree[i1].weight)
			{
				i2 = i1; i1 = i;
			}
			else if (huffTree[i].weight < huffTree[i2].weight)
			{
				i2 = i;
			}
		}
	}
}
3.析构

使用数组静态存储，无需释放空间，析构函数为空

4.输出函数

输出构造的二叉树中叶子结点到根结点的路径及每个结点的权值

输出时，从叶子结点出发，一直到根结点，输出路径及权重。

void HuffmanTree::Print( ){	
	//输出构造的二叉树中叶子结点到根结点的路径及每个结点的权值（每个结点的数值为孩子权值之和） 
	int i,k;//i用来遍历最初的叶子结点,K用来遍历有孩子的结点（非叶子结点） 
	cout << "叶子到根结点的路径:" << endl; 
	
	for(i=0;i<num;i++){
		cout << huffTree[i].weight;
		k = huffTree[i].parent;
		while (k != -1)	//循环输出结点 
		{
			cout << "-->" << huffTree[k].weight;
			k = huffTree[k].parent;		//继续往上找叶子结点的父结点的父结点（直到根结点） 
		}
		cout << endl;
	}
}
类的完整代码
class HuffmanTree
{
public:
	HuffmanTree(int w[ ], int n);
	HuffmanTree( );
	void Print( );
private:
	ElemType *huffTree;
	int num;
	void Select(int n, int &i1, int &i2);
};

void HuffmanTree::Select(int n, int &i1, int &i2)
{
	int temp;
	int i = 0;
	for ( ; i < n; i++)
		if (huffTree[i].parent == -1) {i1 = i; break;}
	for (i = i + 1; i < n; i++)
		if (huffTree[i].parent == -1) {i2 = i;break;}
	if (huffTree[i1].weight > huffTree[i2].weight)  //左边大于右边
	{
		temp = i1; i1 = i2;i2 = temp;               //小的是左孩子、大的是右孩子
	}
	//从i2的下一位置开始遍历，继续找小的元素，更新i1、i2的值
		for (i = i + 1; i < n; i++)
	{
		if (huffTree[i].parent == -1)
		{
			if (huffTree[i].weight < huffTree[i1].weight)
			{
				i2 = i1; i1 = i;
			}
			else if (huffTree[i].weight < huffTree[i2].weight)
			{
				i2 = i;
			}
		}
	}
}

HuffmanTree::HuffmanTree(int w[ ], int n){
    //构造哈夫曼树
    num=n;
    huffTree=new ElemType[2*n-1];		//建立存储数组 
    int i,k,i1,i2;                      //i为叶子结点循环变量，k标记求和后的节点，i1、i2标记最小次小元素位置
    for(int i=0;i<2*num-1;i++){           //初始化，将parent、lchild、rchild均置为-1
    huffTree[i].parent=-1;
    huffTree[i].lchild=huffTree[i].rchild=-1;
    }
    
    for(int i=0;i<num;i++){
        huffTree[i].weight=w[i];	//传叶子结点 
    }

    for(int k=num;k<2*num-1;k++){   //k从数组最后开始，对应权值存储权重数组内最小的俩元素下标

        Select( k ,i1,i2 );
        huffTree[k].weight = huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent= k; huffTree[i2].parent=k;
        huffTree[k].lchild = i1;huffTree[k].rchild = i2;
    }
}

void HuffmanTree::Print( ){	
	//输出构造的二叉树中叶子结点到根结点的路径及每个结点的权值（每个结点的数值为孩子权值之和） 
	int i,k;//i用来遍历最初的叶子结点,K用来遍历有孩子的结点（非叶子结点） 
	cout << "叶子到根结点的路径:" << endl; 
	
	for(i=0;i<num;i++){
		cout << huffTree[i].weight;
		k = huffTree[i].parent;
		while (k != -1)	//循环输出结点 
		{
			cout << "-->" << huffTree[k].weight;
			k = huffTree[k].parent;		//继续往上找叶子结点的父结点的父结点（直到根结点） 
		}
		cout << endl;
	}
}

主函数

主函数部分使用C++动态数组，可自定义叶子节点数目。通过调用类的对象，完成建树并输出。

int main(){
	int n;
	cout<<"输入叶子结点的数量：";
	cin>>n; 
	int *h = new int [n]; 
	cout<<"输入叶子结点的权值："; 
	for(int i=0;i<n;i++) 
		cin>>h[i];
	
	cout<<"-------------------------------------"<<endl;
	cout<<"叶子结点的权值分别是：";
	for(int i=0;i<n;i++)
		cout<<h[i]<<" ";
		cout<<endl;
	
	cout<<"-------------------------------------"<<endl;
	HuffmanTree H(h, 4);
	H.Print();
	
	delete []h;
	
	return 0;
}

程序完整源码

#include<iostream>
using namespace std;
struct ElemType{
    int weight;
    int parent,lchild,rchild;
};
class HuffmanTree
{
public:
	HuffmanTree(int w[ ], int n);
	HuffmanTree( );
	void Print( );
private:
	ElemType *huffTree;
	int num;
	void Select(int n, int &i1, int &i2);
};

void HuffmanTree::Select(int n, int &i1, int &i2)
{
	int temp;
	int i = 0;
	for ( ; i < n; i++)
		if (huffTree[i].parent == -1) {i1 = i; break;}
	for (i = i + 1; i < n; i++)
		if (huffTree[i].parent == -1) {i2 = i;break;}
	if (huffTree[i1].weight > huffTree[i2].weight)  //左边大于右边
	{
		temp = i1; i1 = i2;i2 = temp;               //小的是左孩子、大的是右孩子
	}
	//从i2的下一位置开始遍历，继续找小的元素，更新i1、i2的值
		for (i = i + 1; i < n; i++)
	{
		if (huffTree[i].parent == -1)
		{
			if (huffTree[i].weight < huffTree[i1].weight)
			{
				i2 = i1; i1 = i;
			}
			else if (huffTree[i].weight < huffTree[i2].weight)
			{
				i2 = i;
			}
		}
	}
}

HuffmanTree::HuffmanTree(int w[ ], int n){
    //构造哈夫曼树
    num=n;
    huffTree=new ElemType[2*n-1];		//建立存储数组 
    int i,k,i1,i2;                      //i为叶子结点循环变量，k标记求和后的节点，i1、i2标记最小次小元素位置
    for(int i=0;i<2*num-1;i++){           //初始化，将parent、lchild、rchild均置为-1
    huffTree[i].parent=-1;
    huffTree[i].lchild=huffTree[i].rchild=-1;
    }
    
    for(int i=0;i<num;i++){
        huffTree[i].weight=w[i];	//传叶子结点 
    }

    for(int k=num;k<2*num-1;k++){   //k从数组最后开始，对应权值存储权重数组内最小的俩元素下标

        Select( k ,i1,i2 );
        huffTree[k].weight = huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent= k; huffTree[i2].parent=k;
        huffTree[k].lchild = i1;huffTree[k].rchild = i2;
    }
}

void HuffmanTree::Print( ){	
	//输出构造的二叉树中叶子结点到根结点的路径及每个结点的权值（每个结点的数值为孩子权值之和） 
	int i,k;//i用来遍历最初的叶子结点,K用来遍历有孩子的结点（非叶子结点） 
	cout << "叶子到根结点的路径:" << endl; 
	
	for(i=0;i<num;i++){
		cout << huffTree[i].weight;
		k = huffTree[i].parent;
		while (k != -1)	//循环输出结点 
		{
			cout << "-->" << huffTree[k].weight;
			k = huffTree[k].parent;		//继续往上找叶子结点的父结点的父结点（直到根结点） 
		}
		cout << endl;
	}
}

int main(){
	int n;
	cout<<"输入叶子结点的数量：";
	cin>>n; 
	int *h = new int [n]; 
	cout<<"输入叶子结点的权值："; 
	for(int i=0;i<n;i++) 
		cin>>h[i];
	
	cout<<"-------------------------------------"<<endl;
	cout<<"叶子结点的权值分别是：";
	for(int i=0;i<n;i++)
		cout<<h[i]<<" ";
		cout<<endl;
	
	cout<<"-------------------------------------"<<endl;
	HuffmanTree H(h, 4);
	H.Print();
	
	delete []h;
	
	return 0;
}
rliu2002
关注
专栏目录
哈夫曼树C++实现
04-24
数据结构编码实战：哈夫曼树c++实现可以 定义，哈夫曼各种函数实现
哈夫曼树c++实现
05-17
哈夫曼树
C++数据结构-哈夫曼树的介绍、查找算法与编码（进阶篇）
最新发布
Dola的博客
09-17 987
其次，将刚才合成的数据作为右孩子，左孩子从未处理的数据中选出最小的一个，作为左孩子，他们的根同样为左右孩子的权值和。由上文的分析可知，构建哈夫曼树时，我们需要根据各个结点的权重值，筛选出其中值最小的两个结点，构建二叉树。霍夫曼编码是一种无前缀编码。不断重复上述的步骤，直到将所有的数据全部处理完并构建出二叉树，这棵二叉树就是我们的哈夫曼树。首先，选出我们数据中最小的两个数据，构建成二叉树的左孩子和右孩子，而根的数据为两者之和。d) 结点的带权路径长度：指的是从根结点到该结点之间的路径长度与该结点的权的乘积。
哈夫曼树（C++实现）
热门推荐
Edison's 小宇宙
08-25 3万+
哈夫曼树的概念：在含有 n 个带权叶节点的二叉树中，其中带权路径长度（WPL）最小的二叉树，也叫做最优二叉树。
用c++实现哈夫曼树
06-01
用C++实现简单的哈夫曼树，包括：编码，解码，打印输出哈夫曼树，计算压缩比。
哈夫曼树的C++实现
12-23
通信系统中的哈夫曼树的实现，使用C++语言编写，主要使用了C++的输入输出流，其他部分仍用C语言。改程序界面友好。
基于C++实现哈夫曼树huffman.zip
05-10
C++是一种强大且高效的编程语言，它支持面向对象编程，拥有丰富的库支持，并且执行效率高，因此是实现哈夫曼树的理想选择。在C++中实现哈夫曼树通常涉及到以下几个关键步骤： 1. **创建节点**：首先，我们需要定义...
C++哈夫曼编码和哈夫曼译码-数据结构作业
11-08
在"C++哈夫曼编码和哈夫曼译码-数据结构作业"的项目中，`Huffman_Code-main`可能是主程序文件，其中包含了构建哈夫曼树、生成编码、编码文本以及进行译码的实现。可能包括了结构体或类来表示哈夫曼树节点，优先队列...
C++实现哈夫曼编码：面向对象的构建与选优
在这个C++实现中，采用了面向对象的设计，定义了一个名为`HTree`的类来表示哈夫曼树的节点，每个节点包含了权重（weight）、父节点（parent）、左子节点（lchild）和右子节点（rchild）等属性。 首先，`HTree`类中...
C++编程实现哈夫曼树压缩算法详解
通过C++实现哈夫曼树，不仅可以加深对哈夫曼编码算法的理解，还可以锻炼C++编程能力，特别是涉及堆（heap）、优先队列（priority_queue）、二叉树等数据结构的操作和管理。 以下是实现哈夫曼树时可能会涉及到的关键...
构造哈夫曼树C++代码实现
03-02
其实基本是基于C的代码实现的，时间复杂度还可以，变量比较多，但思路很清晰。
C++实现哈夫曼树算法
12-20
如何建立哈夫曼树的，网上搜索一堆，这里就不写了，直接给代码。 1.哈夫曼树结点类：HuffmanNode.h #ifndef HuffmanNode_h #define HuffmanNode_h template struct HuffmanNode { T weight; // 存储权值 HuffmanNode *leftChild, *rightChild, *parent; // 左、右孩子和父结点 }; #endif /* HuffmanNode_h */ 2.哈夫曼树最小堆：HuffmanMinHeap.h #ifndef HuffmanMinHe
C++实现哈夫曼树及哈夫曼编码.rar
06-02
C++实现哈夫曼树及哈夫曼编码，代码简介https://blog.csdn.net/qq_41664447/article/details/90736442，C++源程序可直接运行
C++实现哈夫曼树
Weirdo的博客
05-30 547
哈夫曼树（Huffman Tree）是一种特殊的二叉树，通常用于数据压缩的哈夫曼编码。在哈夫曼树中，频率（或权重）较高的节点离根节点较远，而频率较低的节点离根节点较近。这样，我们可以为频率较低的节点分配较短的编码，为频率较高的节点分配较长的编码，从而实现数据的压缩。本文将详细介绍如何使用C++实现哈夫曼树，并附有完整的代码。
哈夫曼树的实现（C/C++）
Ivan_47的博客
12-17 291
建立： 为了使得树的带权路径最短，需要将权值较大的结点放在较底层，较小的放在较上层。 实现这个过程需要借助队列结构。 用队列存储结点地址，每次选取权值最小的两个结点并出队（可以事先排好次序），申请一个新结点作为它们的父结点，并将父结点入队。重复这个过程直到队列只剩一个结点，即根结点。 //定义结点 typedef struct HuffmanTree { int weight=0;//权值 HuffmanTree *lchild=nullptr;//左子树 HuffmanTree *
关于C++类实现哈夫曼树
Keep_Trying_Go的博客
03-17 1292
该哈夫曼树可以实现的功能： （1）能够通过键盘或者纯文本文件读入字符集的大小n，以及n个字符和权值来建立哈夫曼树，并且把建立好的哈夫曼树存入到HuffmanTree.txt中去。 （2）利用已经建立好的哈夫曼树，对文件中的正文进行编码，将结果存入到文件HuffmanCode.txt中。 （3）利用已经建立好的哈夫曼树将HuffmanCode.txt中的哈夫曼编码进行译码，结果存入到HuffmanText.txt中。 （4）能够按照垂直输出二叉树的方式，将存储在HuffmanTree.txt纯文本文件中的哈夫
【C++】哈夫曼树模拟实现
m0_51064412的博客
11-02 1248
文章目录一. 什么是哈夫曼树1. 基本术语介绍2. 哈夫曼树的概念3. 哈夫曼树的特点二. 为什么要有哈夫曼树1. 表示哈夫曼编码2. 哈夫曼编码的特点三. 哈夫曼树的构造、编码、译码实现1. 场景说明2. 哈夫曼树基本框架3. 哈夫曼树的成员处理**第一步：初始化哈夫曼树**第二步：构造哈夫曼树Select 一. 什么是哈夫曼树 1. 基本术语介绍 在解释什么是哈夫曼树之前，先介绍三个基本术语：节点的路径长度、节点的权重和树的带权路径长度。 节点的路径长度 当前节点到根节点路径中边的个数称为该节点的路
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值