哈夫曼树与哈夫曼编码

最新推荐文章于 2021-12-23 11:24:24 发布
最新推荐文章于 2021-12-23 11:24:24 发布
阅读量661 收藏 2
点赞数
分类专栏： 哈夫曼树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011415955/article/details/38391361
版权

定义：

给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

构造：

1.构成初始集合
　　对给定的n个权值{W1,W2,W3,...,Wi,...,Wn}构成n棵二叉树的初始集合F={T1,T2,T3,...,Ti,...,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算法，一般还要求以Ti的权值Wi的升序排列。） 
2.选取左右子树
　　在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。 
3.删除左右子树
　　从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。 
4.重复二和三两步，直到集合F中只有一棵二叉树为止。

c++代码实现

#include<iostream>
#include<stdlib.h>
using namespace std;
const int MaxValue =10000;//初始设定的权值最大值
const int MaxBit =4;//初始设定的最大编码位数
const int MaxN=10;//初始设定的最大结点个数
struct HaffNode//哈夫曼树的结点结构
{
	int weight;//权值
	int flag;//标记
	int parent;//双亲结点下标
    int leftChild;//左孩子下标
    int rightChild;//右孩子下标
};
struct Code//存放哈夫曼编码的数据元素结构
{
	int bit[MaxBit];//数组
	int start;//编码的起始下标
	int weight;//字符的权值
};
//weight[]:由小到大排序
void Haffman(int weight[], int n, HaffNode haffTree[])
//建立叶结点个数为n权值为weight的哈夫曼树haffTree
{
	int j,m1,m2,x1,x2;
   //哈夫曼树haffTree初始化。n个叶结点的哈夫曼树共有2n-1个结点
	for(int i=0;i<2*n-1;i++)
	{
		if(i<n)
			haffTree[i].weight=weight[i];
		else
			haffTree[i].weight=0;
        //注意这里没打else那{}，故无论是n个叶子节点还是n-1个非叶子节点都会进行下面4步的初始化
		haffTree[i].parent=0;
		haffTree[i].flag=0;
		haffTree[i].leftChild=-1;
		haffTree[i].rightChild=-1;
	}
	//构造哈夫曼树haffTree的n-1个非叶结点
	for(int i=0;i<n-1;i++)
	{
		m1=m2=MaxValue;//Maxvalue=10000;(就是一个相当大的数)
		x1=x2=0;//x1、x2是用来保存最小的两个值在数组对应的下标
		for(j=i;j<n+i;j++)//循环找出所有权重中，最小的二个值--morgan
		{
			if(haffTree[j].weight<m1&&haffTree[j].flag==0)
			{
				m2=m1;
				x2=x1;
				m1=haffTree[j].weight;
				x1=j;
			}
			else if(haffTree[j].weight<m2&&haffTree[j].flag==0)
			{
				m2=haffTree[j].weight;
				x2=j;
			}
		}
		cout<<"i="<<i<<" "<<m1<<" "<<m2<<endl;
		//将找出的两棵权值最小的子树合并为一棵子树
		haffTree[x1].parent=n+i;
		haffTree[x2].parent=n+i;
		haffTree[x1].flag=1;
		haffTree[x2].flag=1;
		haffTree[n+i].weight=haffTree[x1].weight+haffTree[x2].weight;
		haffTree[n+i].leftChild=x1;
		haffTree[n+i].rightChild=x2;
	}
}
void HaffmanCode(HaffNode haffTree[],int n,Code haffCode[])
//由n个结点的哈夫曼树haffTree构造哈夫曼编码haffCode
{
	Code*cd=new Code;
	int child, parent;

	//求n个叶结点的哈夫曼编码
	for(int i=0;i<n;i++)
	{
		//cd->start=n-1;//不等长编码的最后一位为n-1,
		cd->start=0;//,----修改从0开始计数--morgan
		cd->weight=haffTree[i].weight;//取得编码对应权值的字符
		child=i;
		parent=haffTree[child].parent;
		//由叶结点向上直到根结点
		while(parent!=0)
		{
			if(haffTree[parent].leftChild==child)
				cd->bit[cd->start]=0;//左孩子结点编码0
			else
				cd->bit[cd->start]=1;//右孩子结点编码1
			//cd->start--;
			cd->start++;//改成编码自增--morgan
			child=parent;
			parent=haffTree[child].parent;
		}
		//保存叶结点的编码和不等长编码的起始位
		//for(intj=cd->start+1;j<n;j++)
		for(int j=cd->start-1;j>=0;j--)//重新修改编码，从根节点开始计数--morgan
			haffCode[i].bit[cd->start-j-1]=cd->bit[j];
		
		haffCode[i].start=cd->start;
		haffCode[i].weight=cd->weight;//保存编码对应的权值
	}
}
int main()
{
	int i, j, n=4,m=0;
    int weight[]={2,4,5,7};
	//int weight[]={7,5,4,2};
    HaffNode*myHaffTree=new HaffNode[2*n-1];
    Code*myHaffCode=new Code[n];
    if(n>MaxN)
	{
		cout<<"定义的n越界，修改MaxN!"<<endl;
		exit(0);
	}
	Haffman(weight,n,myHaffTree);
	HaffmanCode(myHaffTree,n,myHaffCode);
    //输出每个叶结点的哈夫曼编码
	for(i=0;i<n;i++)
	{
		cout<<"Weight="<<myHaffCode[i].weight<<" Code=";
		//for(j=myHaffCode[i].start+1;j<n;j++)
		for(j=0;j<myHaffCode[i].start;j++)
			cout<<myHaffCode[i].bit[j];
		m=m+myHaffCode[i].weight*myHaffCode[i].start;
		cout<<"   长度："<<myHaffCode[i].start<<endl;
	}
	cout<<"huffman'sWPLis:";
	cout<<m;
	cout<<endl;
	return 0;
}

c代码实现：

/*-------------------------------------------------------------------------
 * Name:   哈夫曼编码源代码。
 * Date:   2011.04.16
 * Author: Jeffrey Hill+Jezze(解码部分)
 * 在 Win-TC 下测试通过
 * 实现过程：着先通过 HuffmanTree() 函数构造哈夫曼树，然后在主函数 main()中
 *           自底向上开始(也就是从数组序号为零的结点开始)向上层层判断，若在
 *           父结点左侧，则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。
 *------------------------------------------------------------------------*/
#include <stdio.h>
#include<stdlib.h>
 
#define MAXBIT      100
#define MAXVALUE  10000
#define MAXLEAF     30
#define MAXNODE    MAXLEAF*2 -1
 
typedef struct 
{
    int bit[MAXBIT];
    int start;
} HCodeType;        /* 编码结构体 */
typedef struct
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    int value;
} HNodeType;        /* 结点结构体 */
 
/* 构造一颗哈夫曼树 */
void HuffmanTree (HNodeType HuffNode[MAXNODE],  int n)
{ 
    /* i、j： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，
        x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/
    int i, j, m1, m2, x1, x2;
    /* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */
    for (i=0; i<2*n-1; i++)
    {
        HuffNode[i].weight = 0;//权值 
        HuffNode[i].parent =-1;
        HuffNode[i].lchild =-1;
        HuffNode[i].rchild =-1;
        HuffNode[i].value=i; //实际值，可根据情况替换为字母  
    } /* end for */
 
    /* 输入 n 个叶子结点的权值 */
    for (i=0; i<n; i++)
    {
        printf ("Please input weight of leaf node %d: \n", i);
        scanf ("%d", &HuffNode[i].weight);
    } /* end for */
 
    /* 循环构造 Huffman 树 */
    for (i=0; i<n-1; i++)
    {
        m1=m2=MAXVALUE;     /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */
        x1=x2=0;
        /* 找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 */
        for (j=0; j<n+i; j++)
        {
            if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
            {
                m2=m1; 
                x2=x1; 
                m1=HuffNode[j].weight;
                x1=j;
            }
            else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
            {
                m2=HuffNode[j].weight;
                x2=j;
            }
        } /* end for */
            /* 设置找到的两个子结点 x1、x2 的父结点信息 */
        HuffNode[x1].parent  = n+i;
        HuffNode[x2].parent  = n+i;
        HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n+i].lchild = x1;
        HuffNode[n+i].rchild = x2;
 
        printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
        printf ("\n");
    } /* end for */
  /*  for(i=0;i<n+2;i++)
    {
        printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
                  }*///测试 
} /* end HuffmanTree */
 
//解码 
void decodeing(char string[],HNodeType Buf[],int Num)
{
  int i,tmp=0,code[1024];
  int m=2*Num-1;
  char *nump;
  char num[1024];
  for(i=0;i<strlen(string);i++)
  {
   if(string[i]=='0')
  num[i]=0;        
  else
  num[i]=1;                    
  } 
  i=0;
  nump=&num[0];
  
 while(nump<(&num[strlen(string)]))
 {tmp=m-1;
  while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
  {
  
   if(*nump==0)
   {
     tmp=Buf[tmp].lchild ;          
   } 
   else tmp=Buf[tmp].rchild;
   nump++;
        
  } 
  
  printf("%d",Buf[tmp].value);                                  
 }
 
  
}
 
 
int main(void)
{
    
    HNodeType HuffNode[MAXNODE];            /* 定义一个结点结构体数组 */
    HCodeType HuffCode[MAXLEAF],  cd;       /* 定义一个编码结构体数组， 同时定义一个临时变量来存放求解编码时的信息 */
    int i, j, c, p, n;
    char pp[100];
    printf ("Please input n:\n");
    scanf ("%d", &n);
    HuffmanTree (HuffNode, n);
   
    
    for (i=0; i < n; i++)
    {
        cd.start = n-1;
        c = i;
        p = HuffNode[c].parent;
        while (p != -1)   /* 父结点存在 */
        {
            if (HuffNode[p].lchild == c)
                cd.bit[cd.start] = 0;
            else
                cd.bit[cd.start] = 1;
            cd.start--;        /* 求编码的低一位 */
            c=p;                    
            p=HuffNode[c].parent;    /* 设置下一循环条件 */
        } /* end while */
        
        /* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
        for (j=cd.start+1; j<n; j++)
        { HuffCode[i].bit[j] = cd.bit[j];}
        HuffCode[i].start = cd.start;
    } /* end for */
    
    /* 输出已保存好的所有存在编码的哈夫曼编码 */
    for (i=0; i<n; i++)
    {
        printf ("%d 's Huffman code is: ", i);
        for (j=HuffCode[i].start+1; j < n; j++)
        {
            printf ("%d", HuffCode[i].bit[j]);
        }
        printf(" start:%d",HuffCode[i].start);
       
        printf ("\n");
        
    }
/*    for(i=0;i<n;i++){
    for(j=0;j<n;j++)
        {
             printf ("%d", HuffCode[i].bit[j]);           
        }
        printf("\n");
        }*/
    printf("Decoding?Please Enter code:\n");
    scanf("%s",&pp);
decodeing(pp,HuffNode,n);
    getch();
    return 0;
}

参考：




 



old_boy_1991
关注
专栏目录
【C语言】哈夫曼树建立与编码
Read by heart
07-30 2028
原理： 严版教材p144，真题册P163 算法步骤： （1） 赫夫曼树的创建 1）定义赫夫曼树的存储结构，包含指向双亲结点、左右孩子结点的指针、和权值信息； 2）定义一个返回HTNode*类型的函数，用来创建赫夫曼树，闯入的参数为叶子结点n，和权值数组w； 3）根据叶子结点个数确定赫夫曼树结点的个数m，然后定义一个结点指针数组HTNode* HT，作为赫夫曼树； 4）将赫夫曼树初始化...
哈夫曼树和哈夫曼编码
smsmn的专栏
02-21 981
给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。 哈夫曼树的构造   哈夫曼树的构造 假设有n个权值，则构造出的哈夫曼树有n个叶子结点。 n个权值分别设为 w1、w2、…、wn，则哈夫曼树的构造规则为： (1) 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)；
11、创建Huffman树，生成Huffman编码
ajiaoci0000的博客
04-14 192
1 package ren.laughing.datastructure.baseImpl; 2 3 import ren.laughing.datastructure.base.List; 4 5 /** 6 * 创建Huffman树 7 * 生成Huffman编码 8 * @author Laughing_Lz 9 ...
赫夫曼树的定义及构造，赫夫曼编码的定义及构造，算法实现和存储
So_cute_SJM的博客
02-03 1524
文章目录一. 赫夫曼树（最优二叉树）二. 构造赫夫曼树三. 赫夫曼编码四. 构造赫夫曼编码五. 赫夫曼树和赫夫曼编码的存储表示六. 求赫夫曼树和赫夫曼编码的算法 一. 赫夫曼树（最优二叉树） 设二叉树具有n个带权值的叶子结点，从根结点到每一个叶子结点都有一个路径长度。 从根结点到各个叶子结点的路径长度与相应结点权值的乘积的和称为该二叉树的带权路径长度，记作 其中，Wi为第i个叶子结点的权值，L...
数据结构学习笔记（11）哈夫曼树与哈夫曼编码
weixin_52971492的博客
12-15 1699
完整代码+测试函数 Haffman.h #pragma once #include<stdio.h> #include<stdlib.h> //定义哈夫曼树的每个结点，设计哈夫曼树的结点存储结构为双亲孩子存储结构 typedef struct { int weight; int flag; int parent; int leftChild; int rightChild; }HaffNode; //定义哈夫曼编码的结构，start表示每个哈夫曼编码在数组中的起
哈夫曼树与哈夫曼编码介绍.zip
最新发布
04-18
哈夫曼树与哈夫曼编码是数据结构和算法领域中的重要概念，主要应用于数据压缩和效率优化。它们是基于贪心策略的高效算法，旨在最小化带权路径长度（WPL），从而达到最佳编码的效果。 哈夫曼树，又称为最优二叉树或...
哈夫曼树与哈夫曼编码.pdf
04-18
### 哈夫曼树与哈夫曼编码详解 #### 一、哈夫曼树概述 **哈夫曼树**，又称最优二叉树，是一种带权路径长度最短的二叉树，其中的权值是指树中结点被赋予的数值。在哈夫曼树中，每个叶子结点代表一个字符或符号，...
哈夫曼树与哈夫曼编码.docx
04-18
### 哈夫曼树与哈夫曼编码详解 #### 一、哈夫曼树概述 **哈夫曼树（Huffman Tree）**是一种特殊类型的二叉树，它由美国计算机科学家大卫·哈夫曼（David A. Huffman）在1952年提出。哈夫曼树主要用于数据压缩，...
二叉树之哈夫曼树定义-构造-哈夫曼编码
qq_36944952的博客
12-23 1523
二叉树之哈夫曼树的定义-构造-哈夫曼编码1.带权路径长度2.哈夫曼树的构造过程3.哈夫曼树的性质4.哈夫曼树的应用：哈夫曼编码，可以用于数据的压缩。 1.带权路径长度 节点的权：有某种现实意义的数值 节点的带权路径长度：从树的根到该结点的路径长度（经过的边数）与该结点上的权值的乘积 树的带权路径长度：树中所有叶结点的带权路径长度之和（WPL，Wighted Path Length） 哈夫曼树的定义：在含有n个带权叶结点的二叉树中，其中带权路径长度(WPL)最小的二叉树称为哈夫曼树，也成最优二叉树。
哈夫曼树以及编解码
热门推荐
l494926429的博客
09-10 4万+
这一篇要总结的是树中的最后一种，即哈夫曼树，我想从以下几点对其进行总结： 1，什么是哈夫曼树？ 2，如何构建哈夫曼树？ 3，哈夫曼编码？ 4，算法实现？ 回到顶部 一，什么是哈夫曼树 什么是哈夫曼树呢？ 哈夫曼树是一种带权路径长度最短的二叉树，也称为最优二叉树。下面用一幅图来说明。 它们的带权路径长度分别为： 图a： WPL=5*
C语言构造哈夫曼树.rar
04-16
给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
实验四、4哈夫曼树编码
Richard的专栏
05-30 1252
数据结构编程实践（七）创建哈夫曼树、生成哈夫曼编码、完成图片的压缩与解压缩
青红造了个大白之成长记
07-11 1万+
一、对图片的压缩与解压缩，涉及以下内容：1．文件读写2．创建Huffman树3．生成Huffman编码4．压缩图片文件5 .  解压缩图片文件 二、将项目分成三个小任务，下一任务是在上一任务的基础上完成：1．任务一：统计权值、创建Huffman树2．任务二：生成Huffman编码、保存压缩文件3．任务三：解压压缩文件，恢复原文件下面开始完整的步骤：三、统计权值、生成Huffman树1.Huffma...
一句话弄懂常见二叉树类型
许佳佳的博客
11-22 1万+
满二叉树除最后一层无任何子节点外，每一层上的所有结点都有两个子结点二叉树。 完全二叉树一棵二叉树至多只有最下面的一层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。 平衡二叉树它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树 二叉搜索树它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不
哈夫曼树
wysw1998的博客
11-02 421
所以我们的结点要设置一下 typedef struct huffNode { unsigned int weight; //权重 unsigned int lchild, rchild, parent; //左右子节点和父节点 }HTNode, *HuffTree; 在这里插入图片描述 ...
[笔记]: 哈弗曼树（最优二叉树）
Edt!
05-17 451
给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 哈夫曼树（霍夫曼树）又称为最优树. 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第
哈夫曼编码
No_Retreats的专栏
12-04 1204
#include const int MAX=20; //哈夫曼树输入数据的结构 struct huffinit { char data; int weight; }; //哈夫曼树结点的结构 struct huffnode { int weight; int lchild,rchild,parent; }; //哈夫曼树编码的结构 s
数据结构之Haffman树
HopCoder
02-25 528
什么是Haffman树 Haffman树也叫最优二叉树，它是一种带权路径长度WPL最小的树。那么什么叫权 ？ 什么叫路径长度？什么叫WPL？ 路径： 在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长度： 在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点...
哈夫曼树与哈夫曼编码：数据压缩的关键
哈夫曼树与哈夫曼编码是数据压缩领域中的核心概念，它们之间的关系密切且高效。哈夫曼树，也称为最优二叉树，是根据输入数据的频率特性自动生成的一种特殊二叉树，它的主要特点是带权路径长度最短，即从根节点到每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值