哈夫曼编码与解码

最新推荐文章于 2023-05-11 20:39:59 发布
最新推荐文章于 2023-05-11 20:39:59 发布
阅读量1.5k 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 计算机 数据压缩 C++ 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Honkee_/article/details/28302721
版权

这是我的第一篇博客，希望大神们批评指正。

首先介绍以下什么是哈夫曼树（来自百度百科）

哈夫曼树─即最优二叉树，带权路径长度最小的二叉树，经常应用于数据压缩。 在计算机信息处理中，“哈夫曼编码”是一种一致性编码法（又称“熵编码法”），用于数据的无损耗压缩。这一术语是指使用一张特殊的编码表将源字符（例如某文件中的一个符号）进行编码。这张编码表的特殊之处在于，它是根据每一个源字符出现的估算概率而建立起来的（出现概率高的字符使用较短的编码，反之出现概率低的则使用较长的编码，这便使编码之后的字符串的平均期望长度降低，从而达到无损压缩数据的目的）。

构造哈夫曼树的主要思想：

构造哈夫曼树非常简单，将所有的节点放到一个队列中，用一个节点替换两个频率最低的节点，新节点的频率就是这两个节点的频率之和。这样，新节点就是两个被替换节点的父节点了。如此循环，直到队列中只剩一个节点（树根）。


这里用到了最小优先队列。

我这里用STL来实现。（这里有优先队列的介绍）

template<typename T>
struct cmp
{
    bool operator()(TreeNode<T>* t1, TreeNode<T>*  t2)
    {
        return !(*t1 < *t2);
    }
};

优先队列的定义：

priority_queue<TreeNode*,vector<TreeNode* >,cmp > pri_que;

哈夫曼树节点结构

template<typename T>
class TreeNode
{
public:
    TreeNode():pfather(NULL),plchild(NULL),prchild(NULL)
    {

    }
    T data;
    TreeNode *pfather;
    TreeNode *plchild;
    TreeNode *prchild;

    bool operator < (const TreeNode& rhs)
    {
        return data < rhs.data;
    }

};

构造哈夫曼树

每次从最小优先队列取头两个节点，合并后放回最小优先队列，如此重复。

template<typename T>
TreeNode<T>* MakeHuffmanTree(T* begin, T* end) //构造哈夫曼树
{
    priority_queue<TreeNode<T>*,vector<TreeNode<T>* >,cmp<T> > pri_que;
    T *iter = begin;
    TreeNode<T>* pNode;
    TreeNode<T>* pf = NULL;
    while(iter != end)
    {
        pNode = new TreeNode<T>;
        pNode->data = *iter++;
        pNode->pfather = pf;
        pri_que.push(pNode);
    }
    TreeNode<T>* plchild;
    TreeNode<T>* prchild;
    while(pri_que.size() > 1)//取两个小的合并
    {
        plchild = pri_que.top();
        pri_que.pop();
        prchild = pri_que.top();
        pri_que.pop();

        pNode = new TreeNode<T>;
        pNode->plchild = plchild;
        pNode->prchild = prchild;
        pNode->data = plchild->data + prchild->data;

        pri_que.push(pNode);
    }

    pNode = pri_que.top();
    pri_que.pop();
    return pNode;
}


 构造哈夫曼树这个函数的参数是一个结构体，保存着对应字符，其频率，编码值。 

 

重载它的+运算符，为了合并时的+运算（只是频率相加）。
 

 

template<typename T>
struct mydata
{
    mydata(){}
    mydata(int i):freq(i)
    {

    }
    string coded;
    int freq;
    T data;

    bool operator<(const mydata& rhs)
    {
        return freq < rhs.freq;
    }

    mydata operator+(mydata& rhs)
    {
        return mydata(freq + rhs.freq);
    }
};
到此为止，已经可以把哈夫曼树生成出来了。 

 

我们可以通过DFS将每个叶子节点的路径记录下来（用一个全局变量数组path），然后得到它的编码。
 

当发现当前节点是叶子节点，就把当前的路径赋值至该叶子节点的编码属性（coded）。
 

 

const int MAXLEN = 20;
char path[MAXLEN] = {0};
template<typename T>
void DFS(T* root,int deep = -1, char a = '-')  //DFS 得到叶子节点的编码
{
    if(root == NULL)
        return;

    if(a != '-')
        path[deep] = a;

    if(root->plchild == NULL || root->prchild == NULL)//leaf
        (root->data).coded = string(path,path + deep + 1);

    if(root->plchild != NULL)
        DFS(root->plchild, deep + 1, '0');
    if(root->prchild != NULL)
        DFS(root->prchild, deep + 1, '1');
}
这样整个哈夫曼编码工作已经完成，为了查看我们的编码结果，我们可以用BFS跟DFS来看到我们的结果。在这里我选择了BFS。 

 

当遍历到叶子节点，就将其编码属性（coded）和其对应字符输出。
 
 

template<typename T,typename U>
void BFS(T* root, mydata<U>* data) //BFS 将叶子节点的编码，提到data指向的数据
{
    queue<T*> que;
    que.push(root);

    T* pT = NULL;
    while(!que.empty())
    {
        pT = que.front();
        //cout<<pT->data.freq<<endl;
        que.pop();

        if(pT->plchild != NULL)
            que.push(pT->plchild);
        if(pT->prchild != NULL)
            que.push(pT->prchild);
        if(pT->plchild == NULL || pT->prchild == NULL)// leaf 提取叶子节点的编码
        {
			//cout<<(pT->data).data<<":"<<(pT->data).coded<<endl;
			mydata<U>* pd = data;
			while((pT->data).data != pd->data)
				pd++;
			assert(pd->data == (pT->data).data);
			pd->coded = (pT->data).coded;
		}
    }
}
 

 


 
 测试驱动代码 

 

    mydata<char> *pdata = new mydata<char>[4];
    pdata[0].data = 'a';
    pdata[0].freq = 7;
    pdata[1].data = 'b';
    pdata[1].freq = 5;
    pdata[2].data = 'c';
    pdata[2].freq = 2;
    pdata[3].data = 'd';
    pdata[3].freq = 4;
    TreeNode<mydata<char> >* pihuffmanTree = MakeHuffmanTree(pdata, pdata + 4);

    DFS(pihuffmanTree);
    BFS(pihuffmanTree);
 

 为了更方便的使用我将这些封装到一个类里面。 

 

template<typename T>
class Huffman
{
public:
    void Coded(string& coded);//传入待输出的编码
    void DeCode(const string& codedstr,string& decodestr);//输入待解码字符串，输出解码字符串
    void InputData(T* begin,T* end);//传入数据

private:
    string FindVal(char c);
    void m_CalcFreq(T* begin, T* end);//计算输入数据的频率
    TreeNode<mydata<T> > *root;//huffman根节点
    mydata<T>* data;
    int data_size;
	
	T* m_begin;//保存原始数据的开始与结束的位置
	T* m_end;
	//string codedstr;

};
 

 输入数据并计算其频率。 

 

用map容器来统计输入字符每个出现的个数。
 

 

template<typename T>
void Huffman<T>::InputData(T* begin, T* end)
{
	this->m_begin = begin;
	this->m_end = end;
        m_CalcFreq(begin, end);

}

template<typename T>
void Huffman<T>::m_CalcFreq(T* begin, T* end)
{

    int len = end - begin;
    //data_size = len;
    if(len == 0)
        return;

    map<T,int> countMap;
    map<T,int>::iterator mapIter = countMap.begin();
    T *pT = begin;
    while(pT != end)
    {
        mapIter = countMap.find(*pT);
		if(mapIter != countMap.end())//在map里有没有字符*iter
			++mapIter->second;
		else
		{
			countMap.insert(make_pair(*pT,1));
		}
        pT++;
    }

	data_size = countMap.size();
	data = new mydata<T>[data_size];
	int i = 0;
	for (mapIter = countMap.begin(); mapIter != countMap.end(); ++mapIter)
	{
		data[i].data = mapIter->first;		
		data[i].freq = mapIter->second;
		i++;
	}

}
编码 

 

 

template<typename T>
void Huffman<T>::Coded(string& coded)
{
	root = MakeHuffmanTree(data,data + data_size);
	DFS(root);

	BFS(root,data);

	cout<<"code:"<<endl;
	for (int i = 0; i < data_size; ++i)
	{
		cout<<data[i].data<<":"<<data[i].coded<<endl;
	}

	
	T *begin = m_begin;
	while (begin != m_end)
	{
		coded += FindVal(*begin);
		begin++;
	}
	//string subcode = 


}
 

 解码 

 

 

template<typename T>
void Huffman<T>::DeCode(const string& codedstr,string& decodestr)
{
	string::const_iterator iter = codedstr.begin();
	TreeNode<mydata<T> >* curNode = root;
	while (iter != codedstr.end())
	{
		if (curNode->plchild == NULL || curNode->prchild == NULL)
		{
			decodestr += (curNode->data).data;
			curNode = root;
			continue;
		}
		if (*iter == '0')
			curNode = curNode->plchild;
		
		if(*iter == '1')
			curNode = curNode->prchild;

		iter++;
	}
}
 

 测试驱动程序 

 

 

char *pmystr = "cbcddddbbbbaaaaaaa";

    Huffman<char> h;
    h.InputData(pmystr, pmystr + 18);

	cout<<"originstr: "<<pmystr<<endl;

	string coded;
	h.Coded(coded);

	cout<<"coded: "<<coded<<endl;

	string decode;
	h.DeCode(coded,decode);
	cout<<"decode: "<<decode<<endl;
 

 


 
 

完整程序(环境：VS2012)
 

#include <iostream>
//#include <algorithm>
#include <queue>
#include <string>
#include <vector>
#include <cassert>
#include <map>
using namespace std;


template<typename T>
class TreeNode
{
public:
    TreeNode():pfather(NULL),plchild(NULL),prchild(NULL)
    {


    }
    T data;
    TreeNode *pfather;
    TreeNode *plchild;
    TreeNode *prchild;


    bool operator < (const TreeNode& rhs)
    {
        return data < rhs.data;
    }


};


template<typename T>
struct cmp
{
    bool operator()(TreeNode<T>* t1, TreeNode<T>*  t2)
    {
        return !(*t1 < *t2);
    }
};




template<typename T>
TreeNode<T>* MakeHuffmanTree(T* begin, T* end) //构造哈夫曼树
{
    priority_queue<TreeNode<T>*,vector<TreeNode<T>* >,cmp<T> > pri_que;
    T *iter = begin;
    TreeNode<T>* pNode;
    TreeNode<T>* pf = NULL;
    while(iter != end)
    {
        pNode = new TreeNode<T>;
        pNode->data = *iter++;
        pNode->pfather = pf;
        pri_que.push(pNode);
    }
    TreeNode<T>* plchild;
    TreeNode<T>* prchild;
    while(pri_que.size() > 1)//取两个小的合并
    {
        //cout<<static_cast<TreeNode<T>* >(pri_que.top())->data<<endl;
        //pri_que.pop();
        plchild = pri_que.top();
        pri_que.pop();
        prchild = pri_que.top();
        pri_que.pop();


        pNode = new TreeNode<T>;
        pNode->plchild = plchild;
        pNode->prchild = prchild;
        pNode->data = plchild->data + prchild->data;


        pri_que.push(pNode);
    }


    pNode = pri_que.top();
    pri_que.pop();
    return pNode;
}


template<typename T>
struct mydata
{
    mydata(){}
    mydata(int i):freq(i)
    {


    }
    string coded;
    int freq;
    T data;


    bool operator<(const mydata& rhs)
    {
        return freq < rhs.freq;
    }


    mydata operator+(mydata& rhs)
    {
        return mydata(freq + rhs.freq);
    }
};


template<typename T,typename U>
void BFS(T* root, mydata<U>* data) //BFS 将叶子节点的编码，提到data指向的数据
{
    queue<T*> que;
    que.push(root);


    T* pT = NULL;
    while(!que.empty())
    {
        pT = que.front();
        //cout<<pT->data.freq<<endl;
        que.pop();


        if(pT->plchild != NULL)
            que.push(pT->plchild);
        if(pT->prchild != NULL)
            que.push(pT->prchild);
        if(pT->plchild == NULL || pT->prchild == NULL)// leaf 提取叶子节点的编码
        {
			//cout<<(pT->data).data<<":"<<(pT->data).coded<<endl;
			mydata<U>* pd = data;
			while((pT->data).data != pd->data)
				pd++;
			assert(pd->data == (pT->data).data);
			pd->coded = (pT->data).coded;
		}
    }
}


const int MAXLEN = 20;
char path[MAXLEN] = {0};
template<typename T>
void DFS(T* root,int deep = -1, char a = '-')  //DFS 得到叶子节点的编码
{
    if(root == NULL)
        return;


    if(a != '-')
        path[deep] = a;


    if(root->plchild == NULL || root->prchild == NULL)//leaf
        (root->data).coded = string(path,path + deep + 1);


    if(root->plchild != NULL)
        DFS(root->plchild, deep + 1, '0');
    if(root->prchild != NULL)
        DFS(root->prchild, deep + 1, '1');
}


template<typename T>
class Huffman
{
public:
    void Coded(string& coded);
    void DeCode(const string& codedstr,string& decodestr);
    void InputData(T* begin,T* end);


private:
	string FindVal(char c);
    void m_CalcFreq(T* begin, T* end);
    TreeNode<mydata<T> > *root;
    mydata<T>* data;
    int data_size;
	
	T* m_begin;
	T* m_end;
	//string codedstr;


};


template<typename T>
void Huffman<T>::InputData(T* begin, T* end)
{
	this->m_begin = begin;
	this->m_end = end;
    m_CalcFreq(begin, end);


}


template<typename T>
void Huffman<T>::m_CalcFreq(T* begin, T* end)
{


    int len = end - begin;
    //data_size = len;
    if(len == 0)
        return;


    map<T,int> countMap;
    map<T,int>::iterator mapIter = countMap.begin();
    T *pT = begin;
    while(pT != end)
    {
        mapIter = countMap.find(*pT);
		if(mapIter != countMap.end())
			++mapIter->second;
		else
		{
			countMap.insert(make_pair(*pT,1));
		}
        pT++;
    }


	data_size = countMap.size();
	data = new mydata<T>[data_size];
	int i = 0;
	for (mapIter = countMap.begin(); mapIter != countMap.end(); ++mapIter)
	{
		data[i].data = mapIter->first;		
		data[i].freq = mapIter->second;
		i++;
	}


}


template<typename T>
void Huffman<T>::Coded(string& coded)
{
	root = MakeHuffmanTree(data,data + data_size);
	DFS(root);


	BFS(root,data);


	cout<<"code:"<<endl;
	for (int i = 0; i < data_size; ++i)
	{
		cout<<data[i].data<<":"<<data[i].coded<<endl;
	}


	
	T *begin = m_begin;
	while (begin != m_end)
	{
		coded += FindVal(*begin);
		begin++;
	}
	//string subcode = 




}


template<typename T>
void Huffman<T>::DeCode(const string& codedstr,string& decodestr)
{
	string::const_iterator iter = codedstr.begin();
	TreeNode<mydata<T> >* curNode = root;
	while (iter != codedstr.end())
	{
		if (curNode->plchild == NULL || curNode->prchild == NULL)
		{
			decodestr += (curNode->data).data;
			curNode = root;
			continue;
		}
		if (*iter == '0')
			curNode = curNode->plchild;
		
		if(*iter == '1')
			curNode = curNode->prchild;


		iter++;
	}
}


template<typename T>
string Huffman<T>::FindVal(char c)
{
	for (int i = 0; i < data_size ; ++i)
	{
		if (c != data[i].data)
			continue;
		return data[i].coded;
	}
	return string();
}


int main()
{
    //mydata<char> *pdata = new mydata<char>[4];
    //pdata[0].data = 'a';
    //pdata[0].freq = 7;
    //pdata[1].data = 'b';
    //pdata[1].freq = 5;
    //pdata[2].data = 'c';
    //pdata[2].freq = 2;
    //pdata[3].data = 'd';
    //pdata[3].freq = 4;
    int a[12]={14,10,56,7,83,22,36,91,3,47,72,0};
    //TreeNode<mydata<char> >* pihuffmanTree = MakeHuffmanTree(pdata, pdata + 4);


    //DFS(pihuffmanTree);


    //BFS(pihuffmanTree);


    //string str = "cbcddddbbbbaaaaaaa";
	char *pmystr = "cbcddddbbbbaaaaaaa";


    Huffman<char> h;
    h.InputData(pmystr, pmystr + 18);


	cout<<"originstr: "<<pmystr<<endl;


	string coded;
	h.Coded(coded);


	cout<<"coded: "<<coded<<endl;


	string decode;
	h.DeCode(coded,decode);
	cout<<"decode: "<<decode<<endl;


    return 0;
}

 

 

 

 


 

                

        

        

    




    

      

        

            

              
                
                  Honkee
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    5
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
数据结构_哈夫曼树及哈夫曼编码

				
			

			

				

					qq_2210007943的博客
				

				

					07-28
					
					373
					
				

			

		

		

			
				
Huffman树huffman树哈夫曼树的构造代码实现Huffman编码Huffman编码思想代码实现最终完整代码（Huffman树和编码）及测试
huffman树
哈夫曼树又称最优树。是一类带权路径长度最短的树

路径：树中从一个结点到另一个结点之间的分支构成的路径
路径长度：路径上分支的数目
树的路径长度：从树根到每一个结点的路径长度之和
权：赋予实体的一个量，对实体某个或某些属性的数值化。在数据结构中有结点权和边权。
结点的带权路径长度：该结点到根的路径长度和权值的乘积
树的带权路径长度（WPL）：树

			
		

	



                

              
                



	

		

			

				
					
哈夫曼树的建立、编码以及WPL值的计算

					
热门推荐

				
			

			

				

					SSPUmyl的博客
				

				

					12-05
					
					4万+
					
				

			

		

		

			
				
假设用于通信的电文由字符集{A，B，C，D，E，F}中的字母构成，这些字母在电文中出现的概率分别为{0.10，0.19，0.20，0.35，0.12，0.04}，要求： 
1、构造一棵Huffman树，填写下表，要求左结点的权不大于右结点的权 
2、在下表中填入各字符的Huffman编码（左分支为”0”，右分支为”1”） 
3、求带权路径长度 
解析： 
1、哈夫曼树的构造 
   将电文概率由大到

			
		

	



                


  
              

                


	

		

			

				
					
哈夫曼树及哈夫曼编码

				
			

			

				

					qq_43628500的博客
				

				

					12-02
					
					1031
					
				

			

		

		

			
				
一、相关概念
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为：

...

			
		

	





	

		

			

				
					
赫夫曼编码与解码

				
			

			

				

					方亚军的博客
				

				

					03-03
					
					1326
					
				

			

		

		

			
				
赫夫曼编码
基本介绍

赫夫曼编码也翻译为哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法
赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间
赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码

赫夫曼编码原理


通信领域中信息的处...

			
		

	



		

			
		



	

		

			

				
					
哈夫曼编码与解码(C语言实现)

				
			

			

				

					06-01
				

			

		

		

			
				
在C语言中实现哈夫曼编码与解码，主要分为以下几个步骤：  1. **创建哈夫曼树**：  - 首先，我们需要收集输入数据的频率，如字符出现的次数。  - 然后，将这些频率作为权重，创建一个优先队列（通常用最小堆实现）。...

			
		

	





	

		

			

				
					
数字彩色图像的哈夫曼编码与解码的matlab实现

				
			

			

				

					05-23
				

			

		

		

			
				
每组数据个数为 1920×1080，并对这三组数据分别进行哈夫曼编码和解码。计算熵和码字的平均码长。 （2）将彩色图像的像素 R、G、B 值作为独立符号，进行哈夫曼编码和解码，计算熵和码字平均码长。 （3）将彩色图像的...

			
		

	





	

		

			

				
					
哈夫曼编码与解码课程设计PPT

					
最新发布

				
			

			

				

					06-22
				

			

		

		

			
				
哈夫曼编码与解码课程设计的答辩 PPT，注意：使用之前要先去学校电脑试试看看是否能打开，因为内存比较大，学校的电脑普遍较差一点，我答辩的时候就打不开，转成 pdf，硬着讲了。

			
		

	





	

		

			

				
					
基于C++文件的哈夫曼编码与解码.zip

				
			

			

				

					06-21
				

			

		

		

			
				
通过编写利用哈夫曼算法实现的文件编码解码小工具，可加深对哈夫曼算法的理解，以及编码的熟练度。本人的小工具仅针对英文大小字母及 ' '\n' ' ' 字符针对性的进行了哈夫曼编码，若想实现中文及各种支持语言的编码，...

			
		

	





	

		

			

				
					
哈夫曼树及哈夫曼树的编码解码

				
			

			

				

					ZERO_IT_C的博客
				

				

					05-11
					
					2754
					
				

			

		

		

			
				
总节点n = x + y = 边数 + 1 = my + 1   ->    x = (x - 1) / (m - 1)     ->    n = x + y = (m*x - 1) / (m - 1)总节点数n = (m*x - 1) / (m - 1)     //  x为叶子数，m为非叶子节点度数。哈夫曼树又称最优树，它是带权路径长度最小的树，它仅有度为m和度为0的节点（叶子）。②每次选取频度最小的两个字符，分别作为左、右孩子（权重为频度），  O（n）选取1、2，作为左、右孩子，3作为父母节点。

			
		

	





	

		

			

				
					
6-2 哈夫曼编码

				
			

			

				

					qq_63164238的博客
				

				

					05-28
					
					1755
					
				

			

		

		

			
				
函数Select (HuffmanTree HT,int len,int &s1,int &s2)是从1到len中找出parent为0的且权值最小的节点编号赋给s1,s2,（s1的节点编号小于s2），函数void CreatHuffmanTree(HuffmanTree &HT,int n)是构造哈夫曼树，函数void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)计算哈夫曼编码。

函数接口定义：


void 

			
		

	





	

		

			

				
					
哈夫曼编码(文件编码与解码)

				
			

			

				

					qq_41563510的博客
				

				

					04-24
					
					6958
					
				

			

		

		

			
				
利用哈夫曼(Huffman)编码，对text文件中的英文篇章进行编码，并根据编码表对原码进行译码。

			
		

	





	

		

			

				
					
哈夫曼树（huffman）编码、解码

				
			

			

				

					zenozheng的博客
				

				

					01-09
					
					1562
					
				

			

		

		

			
				
哈夫曼树

			
		

	





	

		

			

				
					
Huffman编码与解码（实现任意文章内容压缩）

				
			

			

				

					CXR_XC的博客
				

				

					12-05
					
					2301
					
				

			

		

		

			
				
C++用哈夫曼编码实现对任意英文文章的压缩和还原

			
		

	





	

		

			

				
					
Huffman编码与解码

				
			

			

				

					的博客
				

				

					03-18
					
					1万+
					
				

			

		

		

			
				
使用C++、和Java分别实现构造哈夫曼树

			
		

	





	

		

			

				
					
哈夫曼编解码原理与实现【转载】

				
			

			

				

					Jensen Lee的博客
				

				

					04-01
					
					1万+
					
				

			

		

		

			
				
1. 哈夫曼编解码原理
霍夫曼编码(Huffman Coding)是一种编码方法，霍夫曼编码是可变字长编码(VLC)的一种。
霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。
霍夫曼编码...

			
		

	





	

		

			

				
					
哈夫曼编码和解码

				
			

			

				

					qq_32445015的博客
				

				

					04-17
					
					3219
					
				

			

		

		

			
				
哈夫曼编码和解码， 内部代码纯手工实现 


// hufuman3.cpp.cpp : 定义控制台应用程序的入口点。内部代码纯手工实现
#include &lt;iostream&gt;
#include&lt;stdlib.h&gt;
#include&lt;string.h&gt;

using namespace std;
typedef struct huTreeNode
{
	char...

			
		

	





	

		

			

				
					
哈夫曼编码与解码的C++实现：建立哈夫曼树、进行哈夫曼编码与解码

				
			

			

				

					06-02
				

			

		

		

			
				
好的，以下是哈夫曼编码与解码的C++实现代码：

```c++
#include <iostream>
#include <queue>
#include <unordered_map>
using namespace std;

// 定义哈夫曼树的节点结构体
struct TreeNode {
    char data; // 字符
    int weight; // 权重
    TreeNode* left; // 左子节点
    TreeNode* right; // 右子节点
    TreeNode(char d, int w): data(d), weight(w), left(nullptr), right(nullptr) {}
};

// 定义哈夫曼树节点的比较函数
struct cmp {
    bool operator()(const TreeNode* a, const TreeNode* b) const {
        return a->weight > b->weight;
    }
};

// 建立哈夫曼树
TreeNode* buildHuffmanTree(const string& text) {
    // 统计每个字符在字符串中出现的次数
    unordered_map<char, int> charFreq;
    for (char c : text) {
        charFreq[c]++;
    }
    // 将每个字符的出现次数和字符本身存入优先队列中
    priority_queue<TreeNode*, vector<TreeNode*>, cmp> pq;
    for (auto p : charFreq) {
        pq.push(new TreeNode(p.first, p.second));
    }
    // 不断取出优先队列中的两个最小节点，合并成一个新节点，再将新节点放回优先队列中
    while (pq.size() > 1) {
        TreeNode* left = pq.top();
        pq.pop();
        TreeNode* right = pq.top();
        pq.pop();
        TreeNode* parent = new TreeNode('\0', left->weight + right->weight);
        parent->left = left;
        parent->right = right;
        pq.push(parent);
    }
    // 最后的队列头即为整个哈夫曼树的根节点
    return pq.top();
}

// 哈夫曼编码
void encodeHuffman(TreeNode* root, string code, unordered_map<char, string>& huffmanCode) {
    if (!root) {
        return;
    }
    if (!root->left && !root->right) {
        huffmanCode[root->data] = code;
        return;
    }
    encodeHuffman(root->left, code + "0", huffmanCode);
    encodeHuffman(root->right, code + "1", huffmanCode);
}

// 哈夫曼解码
string decodeHuffman(TreeNode* root, string huffmanCode) {
    string decodeText = "";
    TreeNode* cur = root;
    for (char c : huffmanCode) {
        if (c == '0') {
            cur = cur->left;
        } else {
            cur = cur->right;
        }
        if (!cur->left && !cur->right) {
            decodeText += cur->data;
            cur = root;
        }
    }
    return decodeText;
}

int main() {
    string text = "this is a test text";
    TreeNode* root = buildHuffmanTree(text);
    unordered_map<char, string> huffmanCode;
    encodeHuffman(root, "", huffmanCode);
    for (auto p : huffmanCode) {
        cout << p.first << ": " << p.second << endl;
    }
    string huffmanCodeText = "";
    for (char c : text) {
        huffmanCodeText += huffmanCode[c];
    }
    cout << "Huffman code: " << huffmanCodeText << endl;
    string decodeText = decodeHuffman(root, huffmanCodeText);
    cout << "Decode text: " << decodeText << endl;
    return 0;
}
```

上述代码首先实现了哈夫曼树的建立，然后通过递归实现了哈夫曼编码和解码。在编码时，对于每个字符，我们都可以通过哈夫曼树得到其对应的哈夫曼编码；在解码时，我们只需要从根节点开始，依次遍历哈夫曼树，直到遇到叶子节点，就可以得到该叶子节点所代表的字符。最终输出的结果是原始字符串的哈夫曼编码和解码后的字符串。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值