最小堆实现哈夫曼树的构造及哈夫曼编码、解码

最新推荐文章于 2024-01-24 23:21:54 发布
最新推荐文章于 2024-01-24 23:21:54 发布
阅读量1.4k 收藏 21
点赞数 3
分类专栏： 数据结构知识点
原文链接：https://blog.csdn.net/Authur520/article/details/84781037?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1
版权

原文链接：https://blog.csdn.net/Authur520/article/details/84781037?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

最小堆建哈夫曼树

测试用例：

5
1  2  3  4  5

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define MinData -10001
typedef struct Heap *MinHeap;
typedef struct HTNode *HuffmanTree;
struct Heap{
    HuffmanTree *data;//存储堆元素的数组，存储时从下标1开始 
    int Size;    //记录当前堆元素个数
    int Capacity;   //堆的最大容量
};
struct HTNode{
	int Weight;//权值 
	HuffmanTree Left;
	HuffmanTree Right;
};

MinHeap CreateMinHeap(int MaxSize);//建一个最小堆 
bool Insert(MinHeap H,HuffmanTree item);//将新T插入最小堆 
HuffmanTree DeleteMin(MinHeap H);//从最小堆中删除一个结点，作为新T的子节点
MinHeap BuildMinHeap(MinHeap H);//将H->data[]按权值Weight调整为最小堆 
HuffmanTree Huffman(MinHeap H);//构造哈夫曼树 
void PreOrderTraversal(HuffmanTree BST);//先序遍历 
void Inorder(HuffmanTree BST);//中序遍历 
bool IsFull(MinHeap H);
bool IsEmpty(MinHeap H);
int main()
{
	int i,N;
	MinHeap H;
	HuffmanTree T,BT=NULL;
	printf("请输入叶子结点的个数:\n"); 
	scanf("%d",&N);
	H=CreateMinHeap(2*N);
	printf("请输入%d个叶子结点对应的权值:\n",N);
	for(i=1; i<=N; i++){/*最小堆元素赋值*/ 
		T=(HuffmanTree)malloc(sizeof(struct HTNode));
		T->Weight = 0;
		T->Left = T->Right = NULL;
		scanf("%d",&(T->Weight));
		H->data[++(H->Size)] = T;
	}
	
	BT = Huffman(H);  //构造哈夫曼树 
	printf("先序遍历此哈夫曼树的权值:\n"); 
	PreOrderTraversal(BT);  //先序遍历此哈夫曼树 
	puts("");
	printf("中序遍历此哈夫曼树的权值:\n");
	Inorder(BT);//中序遍历此哈夫曼树 
	return 0;
}

HuffmanTree Huffman(MinHeap H)//构造哈夫曼树 
{
/*假设H->Size个权值已经存在H->data[]->Weight里*/
	int i,N;
	HuffmanTree T;
	BuildMinHeap( H );//将H->data[]按权值调整为最小堆
	N=H->Size;
	for(i=1;i<N;i++)//做 H->Size-1次合并 
	{
		T=(HuffmanTree)malloc(sizeof(struct HTNode)); //建立一个新的根结点 
		T->Weight = 0;
		T->Left = T->Right = NULL;
		T->Left=DeleteMin(H); //从最小堆中删除一个节点，作为新T的左子结点
		T->Right=DeleteMin(H);//从最小堆中删除一个节点，作为新T的右子结点 
		T->Weight=T->Left->Weight+T->Right->Weight;//计算新权值 
		Insert(H,T);//将新T插入到最小堆 
	}
	return DeleteMin(H);
}
MinHeap CreateMinHeap(int MaxSize)
{/*创建容量为MaxSize的最小堆*/
    MinHeap H = (MinHeap)malloc(sizeof(struct Heap));
    H->data = (HuffmanTree*)malloc((MaxSize+1)*sizeof(HuffmanTree));
    H->Size = 0;
    H->Capacity = MaxSize;
    HuffmanTree T=(HuffmanTree)malloc(sizeof(struct HTNode)); //建立一个新的根结点 
    //定义哨兵-小于堆中所有可能元素权值的值 
    T->Weight = 0;
	T->Left = T->Right = NULL;
    T->Weight=MinData;
    H->data[0] =T;
	return H;
}
bool IsFull(MinHeap H)
{
	return (H->Size==H->Capacity);
}
bool IsEmpty(MinHeap H)
{
	return (H->Size==0);
}
bool Insert(MinHeap H,HuffmanTree item)
{
    int i;
	if( IsFull(H) ){
		printf("最小堆已满\n");
		return false;
	}
	i = ++H->Size;  //i指向插入后堆中的最后一个元素的位置
	for(; H->data[i/2]->Weight > item->Weight; i/=2)  //无哨兵，则增加判决条件 i>1 
	    H->data[i] = H->data[i/2];  //向下过滤结点 
	H->data[i] = item;   //将item插入 
	
	return true;  
    
}
HuffmanTree DeleteMin(MinHeap H)
{/*从最小堆H中取出权值为最小的元素，并删除一个结点*/
	int parent,child;
	HuffmanTree MinItem,temp = NULL;
	if( IsEmpty(H) ){
		printf("最小堆为空\n");
		return NULL;
	}
	MinItem = H->data[1];  //取出根结点-最小的元素-记录下来
	/*用最小堆中的最后一个元素从根结点开始向上过滤下层结点*/
	temp = H->data[H->Size--];  //最小堆中最后一个元素，暂时将其视为放在了根结点
	for(parent=1; parent*2<=H->Size; parent=child){
		child = parent*2;
		if((child != H->Size) && (H->data[child]->Weight > H->data[child+1]->Weight)){/*有右儿子，并且左儿子权值大于右儿子*/
			child++; //child指向左右儿子中较小者 
		}
		if(temp->Weight > H->data[child]->Weight){
			H->data[parent] = H->data[child];  //向上过滤结点-temp存放位置下移到child位置 
		}else{
			break;  //找到了合适的位置
		}
	} 
	H->data[parent] = temp;  //temp存放到此处
	
	return MinItem; 
}
MinHeap BuildMinHeap(MinHeap H)
{/*这里假设所有的H->Size个元素已经存在H->data[]中*/
 /*本函数将H->data[]中的元素调整，使其满足堆的有序性*/ 
	int i,parent,child;
	HuffmanTree temp;
	for(i=H->Size/2;i>0;i--){  //从最后一个父结点开始，直到根结点 
		temp = H->data[i];
		for(parent=i; parent*2<=H->Size; parent=child){
		    /*向下过滤*/
			child = parent*2;
		    if((child != H->Size) && (H->data[child]->Weight > H->data[child+1]->Weight)){/*有右儿子，并且左儿子权值大于右儿子*/
			    child++; //child指向左右儿子中较小者 
		    }
		    if(temp->Weight > H->data[child]->Weight){
			    H->data[parent] = H->data[child];  //向上过滤结点-temp存放位置下移到child位置 
		    }else{
			    break;  //找到了合适的位置 
		    }
	    }/*结束内部for循环对以H->data[i]为根的子树的调整*/
		
		H->data[parent] = temp;  //temp（原H->data[i]）存放到此处  
	} 
	return H; 
}
void PreOrderTraversal(HuffmanTree BST)
{
	if( BST ){
		printf("%d ",BST->Weight);     //先访问根节点 
		PreOrderTraversal(BST->Left);  //再访问左子树 
		PreOrderTraversal(BST->Right); //最后访问右子树 
	}
}
void Inorder(HuffmanTree BST)
{
	if(BST)
	{
		Inorder(BST->Left);//先访问左子树 
		printf("%d ",BST->Weight);//再访问根节点 
		Inorder(BST->Right);//最后访问右子树 
	}
}

增加了哈夫曼编码、解码

测试用例：

6
6  3  8  2  10  4
a  b  c  d   e  f

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MinData -10001  //随着堆元素的具体值而改变  

typedef struct TreeNode *HuffmanTree;
typedef struct TreeNode{
	char ch;  //要编码的字符 
	int Weight;  //权值
	HuffmanTree Left;
	HuffmanTree Right; 
}HuffmanNode;
 
typedef struct HeapStruct *MinHeap;
struct HeapStruct{
	HuffmanTree *data;  //存储堆元素的数组  存储时从下标1开始 
	int Size;  //堆的当前元素的个数
	int Capacity;  //堆的最大容量 
};
 
HuffmanTree NewHuffmanNode();
MinHeap CreateMinHeap(int MaxSize);
bool Insert(MinHeap H,HuffmanTree item);
HuffmanTree DeleteMin(MinHeap H);
MinHeap BuildMinHeap(MinHeap H);
HuffmanTree Huffman(MinHeap H);
void PreOrderTraversal(HuffmanTree BST);
void HuffmanCode(HuffmanTree BST,int depth);//编码 
 
int main()
{
	int i,N;
	MinHeap h;
	HuffmanTree T,BT = NULL;
	
	printf("请输入叶子结点的个数:\n"); 
	scanf("%d",&N);
	h = CreateMinHeap(2*N);  //创建最小堆   //N个叶子节点最终形成的哈夫曼树最多有2N-1个树结点 
	printf("请输入%d个叶子结点对应的权值:\n",N); 	
	for(i=1; i<=N; i++){/*最小堆元素赋值*/ 
		T = NewHuffmanNode();
		scanf("%d",&(T->Weight));
		//scanf("%d-%c",&(T->Weight),&(T->ch));
		h->data[++(h->Size)] = T;
	}
	char string[100]; 
	printf("请连续输入这%d个叶子结点各自代表的字符:\n",N); 
	getchar();  //吸收上面的换行符 
	gets(string);
	for(i=1; i<=h->Size; i++){/*最小堆元素赋值*/ 
		h->data[i]->ch= string[i-1];
	}
	
	BT = Huffman(h);  //构造哈夫曼树 
	printf("\n");
	HuffmanCode(BT,0);	
	return 0;
 } 
 
 /*哈夫曼树构造算法*/
HuffmanTree Huffman(MinHeap H)
 {/*假设H->Size个权值已经存在H->data[]->Weight里*/
 	int i,num;
	HuffmanTree T;
	
	BuildMinHeap( H );  //将H->data[]按权值调整为最小堆
	/*此处必须将H->Size的值交给num,因为后面做DeleteMin()和 Insert()函数会改变H->Size的值*/
	num = H->Size;     
	for(i=1; i<num; i++){  //做 H->Size-1次合并   //此处教科书有问题！
		T = NewHuffmanNode();  //建立一个新的根结点 
		T->Left = DeleteMin(H);  //从最小堆中删除一个节点，作为新T的左子结点
		T->Right = DeleteMin(H);  //从最小堆中删除一个节点，作为新T的右子结点 
		T->Weight = T->Left->Weight+T->Right->Weight;  //计算新权值 
		Insert(H,T);  //将新T插入到最小堆 
	} 
	T = DeleteMin(H);
	
	return T; 
  } 
  
/************递归进行哈夫曼编码*************/
void HuffmanCode(HuffmanTree BST,int depth)  //depth为目前编码到哈夫曼树的深度（层次） 
{
	static int code[10];  //编码空间 
	
	if( BST ){
		if( (BST->Left == NULL) && (BST->Right == NULL)){  //找到了叶结点
			printf("字符%c的哈夫曼编码为：",BST->ch);
			for(int i=0; i<depth; i++){
				printf("%d",code[i]);
			}
			printf("\n");
		}else{
			code[depth] = 0;  //往左子树方向编码为0 
			HuffmanCode(BST->Left,depth+1);
			code[depth] = 1;  //往右子树方向编码为1 
			HuffmanCode(BST->Right,depth+1);
		}
	} 
}


HuffmanTree NewHuffmanNode()
{
	HuffmanTree BST = (HuffmanTree)malloc(sizeof(HuffmanNode));
	BST->Weight = 0;
	BST->Left = BST->Right = NULL;
	
	return BST;
 } 
  
MinHeap CreateMinHeap(int MaxSize)
{  /*创建容量为MaxSize的最小堆*/
	MinHeap H = (MinHeap)malloc(sizeof(struct HeapStruct));
	H->data = (HuffmanTree *)malloc((MaxSize+1) * sizeof(HuffmanTree));
	H->Size = 0;
	H->Capacity = MaxSize;
	HuffmanTree T = NewHuffmanNode();
	T->ch = '\0';  //空字符 
	T->Weight = MinData;  /*定义哨兵-为小于堆中所有可能元素权值的值，便于以后更快操作*/
	H->data[0] = T;
	
	return H;
}
 
bool  IsFull(MinHeap H)
{
	return (H->Size == H->Capacity);
}
 
bool IsEmpty(MinHeap H)
{
	return (H->Size == 0);
}
 
/*插入算法-将新增结点插入到从其父结点到根结点的有序序列中*/
bool Insert(MinHeap H,HuffmanTree item)
{/*将元素item插入到最小堆H中，其中H->data[0]已被定义为哨兵*/
	int i;
	if( IsFull(H) ){
		printf("最小堆已满\n");
		return false;
	}
	i = ++H->Size;  //i指向插入后堆中的最后一个元素的位置
	for(; H->data[i/2]->Weight > item->Weight; i/=2)  //无哨兵，则增加判决条件 i>1 
	    H->data[i] = H->data[i/2];  //向下过滤结点 
	H->data[i] = item;   //将item插入 
	
	return true;
 }
 
HuffmanTree DeleteMin(MinHeap H)
{/*从最小堆H中取出权值为最小的元素，并删除一个结点*/
	int parent,child;
	HuffmanTree MinItem,temp = NULL;
	if( IsEmpty(H) ){
		printf("最小堆为空\n");
		return NULL;
	}
	MinItem = H->data[1];  //取出根结点-最小的元素-记录下来
	/*用最小堆中的最后一个元素从根结点开始向上过滤下层结点*/
	temp = H->data[H->Size--];  //最小堆中最后一个元素，暂时将其视为放在了根结点
	for(parent=1; parent*2<=H->Size; parent=child){
		child = parent*2;
		if((child != H->Size) && (H->data[child]->Weight > H->data[child+1]->Weight)){/*有右儿子，并且左儿子权值大于右儿子*/
			child++; //child指向左右儿子中较小者 
		}
		if(temp->Weight > H->data[child]->Weight){
			H->data[parent] = H->data[child];  //向上过滤结点-temp存放位置下移到child位置 
		}else{
			break;  //找到了合适的位置
		}
	} 
	H->data[parent] = temp;  //temp存放到此处
	
	return MinItem; 
}
 
MinHeap BuildMinHeap(MinHeap H)
{/*这里假设所有的H->Size个元素已经存在H->data[]中*/
 /*本函数将H->data[]中的元素调整，使其满足堆的有序性*/ 
	int i,parent,child;
	HuffmanTree temp;
	for(i=H->Size/2;i>0;i--){  //从最后一个父结点开始，直到根结点 
		temp = H->data[i];
		for(parent=i; parent*2<=H->Size; parent=child){
		    /*向下过滤*/
			child = parent*2;
		    if((child != H->Size) && (H->data[child]->Weight > H->data[child+1]->Weight)){/*有右儿子，并且左儿子权值大于右儿子*/
			    child++; //child指向左右儿子中较小者 
		    }
		    if(temp->Weight > H->data[child]->Weight){
			    H->data[parent] = H->data[child];  //向上过滤结点-temp存放位置下移到child位置 
		    }else{
			    break;  //找到了合适的位置 
		    }
	    }/*结束内部for循环对以H->data[i]为根的子树的调整*/
		
		H->data[parent] = temp;  //temp（原H->data[i]）存放到此处  
	} 
	return H; 
}
chstor
关注
专栏目录
【数据结构】哈夫曼树及哈夫曼编码实现（C语言）
weixin_51450101的博客
02-12 6万+
目录1. 哈夫曼树1.1 基本概念1.2 构造哈夫曼树1.3 哈夫曼树的类型定义1.4 哈夫曼树创建的算法实现2. 哈夫曼编码实现2.1 哈夫曼编码2.2 完整代码2.3 运行结果 1. 哈夫曼树 1.1 基本概念 路径：指从根结点到该结点的分支序列。 路径长度：指根结点到该结点所经过的分支数目。 结点的带权路径长度：从树根到某一结点的路径长度与该结点的权的乘积。 树的带权路径长度(WPL)：树中从根到所有叶子结点的各个带权路径长度之和。 哈夫曼树是由 n 个带权叶子结点构成的所有二叉树中带权路径长度最短的
最小堆 实现的霍夫曼编码
12-22
输入文件“input.txt”，路径定义在项目默认：Visual Studio 2010\Projects\Poject1\Poject1 以“Huffman”编码对输入进行压缩编码 输出霍夫曼树的结构 输出编码结果、译码结果
利用最小堆实现哈夫曼树
11-17
本资源是数据结构中利用最小堆实现哈夫曼树的一个C++代码，仅供参考，欢迎指正
哈夫曼树的最小堆实现
leoabcd12的博客
06-11 469
哈夫曼树 定义 带权路径长度（WPL）：设二叉树有n个叶子结点，每个叶子节点带有权值Wk，从根结点到每个叶子节点的长度为Lk,则每个叶子结点的带权路径长度之和就是：WPL=∑k=1nWkLkWPL=\sum_{k=1}^{n}W_kL_kWPL=∑k=1n​Wk​Lk​ 特点 没有度为1的结点 n个叶子结点的哈夫曼树共有2n-1个结点 哈夫曼树的任意非叶子结点的左右子树交换后仍是哈夫曼树 同一组权值，存在不同构的哈夫曼树 图解 初始 #mermaid-svg-b6DWuJYTo59uOyOj .labe
哈夫曼树（最小堆实现）
knswd的博客
03-06 1285
哈夫曼树：根据节点的查找频率构建更有效的搜索树 如何构造哈夫曼树：每次从堆中拿出两个权值最小的节点组成新的节点，并放入堆中。重复直到堆中只剩一个元素。 难点在于要保存每次合并后的新节点的地址（在哈夫曼树中的地址） 代码： //用最小堆来实现哈夫曼树的建立 //哈夫曼树简介：根据结点的额不同查找频率构造的更有效的搜索树 #include<iostream> #include<st...
最小堆实现哈夫曼树构造
07-19 1607
0. 序 本以为用最小堆实现个哈夫曼树是个简单的事情，结果一不小心就花了好几个小时才写完。。。实现过程中主要有三个方面的问题没注意，导致花了很多时间进行调试。 一是多重指针malloc分配时要多加注意； 二是指针一定要记得初始化，默认不一定为NULL； 三是结构体赋值问题。 其余的边界问题小心就好了。。另，由于本人水平有限，如有任何问题，欢迎指出解决，谢谢大家！详细结果如下： 1...
C++实现哈夫曼树编码解码
12-20
哈夫曼树是一种特殊的二叉树，用于数据压缩和编码，通过构建最小带权路径长度（Minimum Weighted Path Length, MWPL）的树形结构来实现高效的数据编码和解码。在C++中，我们可以使用类来表示哈夫曼树的节点和整个树...
【数据结构】最小堆实现哈夫曼树构造与解码
未选之路
09-08 4480
#include #include #include #include using namespace std; #define MAX 100 struct Node{ int weight; //权重 char c; //字符 string code; //解码结果 Node *parent,*left,*right; //初始化 Node(
最小堆构建哈夫曼树
正在挣扎中的人
04-03 1020
最小堆实现哈夫曼树
最小堆实现哈夫曼树编码和译码（纯c语言）
最新发布
WonderKing'blog
01-24 476
【代码】最小堆实现哈夫曼树编码和译码（纯c语言）
使用最小堆构造哈夫曼树
妙木山
02-27 3215
哈夫曼树： 路径：从树根到某个节点的路径为根节点到该节点所经过的一个节点序列。路径长度为路径所含的分支数。 树的路径长度：从根节点到其他所有节点的路径长度之和。 节点的带权路径长度：从根节点开始到该节点路径长度乘该节点的权值。 树的带权路径长度：整个树的所有节点的带权路径长度之和。 哈夫曼树是带权路径最短的树，也称为最优二叉树。 构造哈夫曼树的算法： 将n个带有权值且只有一个叶节点的二...
最小堆之哈夫曼树编码
artificiali的博客
12-02 180
生成编码：从根节点开始，沿着左子树走为0，右子树走为1，直到到达叶子节点，记录下路径上的0和1，即为字符的哈夫曼编码。构建哈夫曼树：根据字符频率构建哈夫曼树，该树是一种特殊的二叉树，其叶子节点代表字符，而非叶子节点不包含字符。从最小堆中取出两个权值最小的节点，并合并为一个新节点，新节点的权值为这两个节点的权值之和。重复步骤2和3，直到最小堆中只剩下一个节点为止，这个节点就是哈夫曼树的根节点。统计字符频率：首先需要统计待编码的字符集中每个字符出现的频率。创建最小堆：将所有的权重作为节点构建成最小堆。
C语言实现哈夫曼编码(最小堆，二叉树)
weixin_34403693的博客
12-19 443
// 文件中有通过QT实现的界面#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct HNode *Heap; /* 堆的类型定义 */ typedef struct SData myData; typedef struct SData *Huffma...
利用最小堆创建Huffman树代码（C++）
乃乃天外仙
09-25 855
#include"heap.h" #include<time.h> #include<iostream> using namespace std; //Huffman tree node abstract base class template<typename E> class HuffNode { public: virtual ~HuffNode(){...
用最小堆生成哈夫曼树C++
m0_52745381的博客
11-15 367
用最小堆生成哈夫曼树C++
最小堆
ccshijtgc的专栏
01-06 666
最大堆和最小堆是二叉堆的两种形式。 最大堆：根结点的键值是所有堆结点键值中最大者的堆。最小堆：根结点的键值是所有堆结点键值中最小者的堆。 不失一般性，只讨论根结点为最小层的情况。 插入[编辑] 只需要将节点插在二叉树的最后一个叶子结点位置，然后比较它对它父亲节点的大小，如果大则停止；如果小则交换位置，然后对父亲节点递归该过程直至根节点。复杂度为O(log(n
C++实现哈夫曼树构造、编码与解码
`HuffTree`类是核心，它实现了哈夫曼树的构建、选择最优路径、输出树结构、编码和解码功能。 1. 构建HuffTree： - 初始化时，创建一个大小为2n-1的`tree`数组，其中n是输入字符的数量。每个节点的parent、lchild和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值