huffman编码函数

最新推荐文章于 2023-06-04 20:29:48 发布
最新推荐文章于 2023-06-04 20:29:48 发布
阅读量955 收藏
点赞数
文章标签： c++ 哈夫曼 Huffman
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014716362/article/details/24561319
版权

虽然东西简单了点，可能还有错，读者们别介意它太啰嗦，有更好的建议欢迎交流的。放出来希望对像我一样学习编程的人有帮助（虽然看别人的代码貌似是件很痛苦的事啊）。


这里没有用模板函数（人比较懒），，节点的权值都是int，，类函数定义都在类的内部

//哈夫曼树类
class Node
{
public:
	Node *rchild;
	Node *lchild;
	Node *parent;
	int weight;  //权值
	char ch;     //叶子字符
	char node_code;  //每个字符对应的路径（左0右1）
	Node(){};
};
class HuffmanTree
{
protected:
	Node *root;   //根节点
	vector<char> leaf_char;    //从叶节点得到字符
	vector<string>  leaf_code ;   //保存每个字符的编码
public:
	HuffmanTree(int p ,char c){root=new Node();root->weight=p;root->ch=c;}
	HuffmanTree(){root=new Node();}
	void build_tree(int pro[],char cha[],int count)
	{
		HuffmanTree *r[26];
		for(int j=0;j<count;j++)     //初始化每个字符形成的树
		{
			r[j]=new HuffmanTree() ;
			r[j]->root->ch=cha[j];
			r[j]->root->weight=pro[j];
			
		}
		for(int j=0;j<count-1;j++)    //找出数组中根节点权值最小的两个 合并
		{
			for(int i=j+1;i<count;i++)      //找出最小权值的树放入r[j]
			{
				if(r[j]->root->weight>r[i]->root->weight)
				{
					HuffmanTree *temp;
					temp=r[i];
					r[i]=r[j];
					r[j]=temp;
				}
			}
			for(int i=j+2;i<count;i++)     //找出最小权值的树放入r[j+1]
			{
				if(r[j+1]->root->weight>r[i]->root->weight)
				{
					HuffmanTree *temp;
					temp=r[i];
					r[i]=r[j+1];
					r[j+1]=temp;
				}
			}
			HuffmanTree *t_r=new HuffmanTree();    //过渡用的t_r 生成新的树赋给r[j+1]
			t_r->root->lchild=r[j]->root;
			r[j]->root->parent=t_r->root;
			r[j]->root->node_code='0';      //是parent的左孩子，赋予路径0
			t_r->root->rchild=r[j+1]->root;
			r[j+1]->root->parent=t_r->root;
			r[j+1]->root->node_code='1';      //是parent的左孩子，赋予路径1
			t_r->root->weight = r[j]->root->weight+r[j+1]->root->weight;       //左右孩子的权值和
			r[j+1]=t_r;
			if(j+1==count-1)
			root=r[j+1]->root;
		}
	}
	void turn_char_code(Node *h)      //输出每个字符的编码
	{
		string s;
		Node *temp=h;
		if(temp->lchild==NULL && temp->rchild==NULL)  //测到根节点
		{
			char c=temp->ch;
			leaf_char.push_back(temp->ch);
			while (temp->parent!=NULL)   //有父节点则推测哈夫曼编码
			{
				s=temp->node_code+s;
				temp=temp->parent;
			}
			leaf_code.push_back(s);
			cout<<c<<"的哈夫曼编码："<<s<<endl;

		}
		if(h->lchild!=NULL)
		{
			turn_char_code(h->lchild);
		}
		if(h->rchild!=NULL)
		{
			turn_char_code(h->rchild);
		}
	}
	string turn_string_code(string src)  //返回字符串的哈夫曼编码
	{
		string h_string;
		turn_char_code(root);
		for(int j=0;j<src.length();j++)
		{
			for(int k=0;k<leaf_char.size();k++)
			{
				if(src[j]==leaf_char[k])
				h_string=h_string+leaf_code[k];
			}
		}
		return h_string;
	}
	string deCode(string src)
	{
		string s;
		for(int j=0;j<src.length();)
		{
			for(int k=0;k<leaf_char.size();k++)
			{
				int code_length=leaf_code[k].length();
				if(src.substr(j,code_length)==leaf_code[k])     //以j开头的code_length个字符为字串与leaf_code对比
				{
					s=s+leaf_char[k];
					j=j+code_length;
				}
			}
		}
		return s;
	}
};
string huffmancoding(const string &src)
{
	cout << "=========== Huffman coding ===========" << endl;
	cout << "Input string   : " << src << endl;

	string destCode;
	/// 在此处添加编码代码，输入为src，输出为destCode
	
	int p[26]; 
	char c[26];
	c[0]=src[0];      
	  //字符串的各字符不重复地放入c[]
		int c_count=1;  //数组c[]的数量
		for(int j=0;j<src.length();j++)
		{
			int k=0;
			for(k=0;k<c_count;k++)    //寻找当前的字符在c[]中是否有记录
			{
				if(c[k]==src[j])       //有记录则跳出循环 且k=0
				{
					k=0;
					break;
				}
			}
			if(k>0)         //在c[]中未找到当前字符
			{
				c_count++;
				c[c_count-1]=src[j];
				
			}
		
		}
	  //计算src中各字符的出现次数 相对应记录于p[]
		for(int j=0;j<=c_count;j++)
		{
			p[j]=0;
			for(int h=0;h<src.length();h++)
			{
				if(src[h]==c[j])
					p[j]++;
			}
		}

	
		HuffmanTree h_tree;
		h_tree.build_tree(p,c,c_count);
	cout << "===== Code for each char :" << endl;	
	destCode=h_tree.turn_string_code(src);			
	cout << "Coded string   : " << destCode << endl;

	/// 此处输出每个字符的编码

	//哈夫曼树类
class Node
{
public:
<span style="white-space:pre">	</span>Node *rchild;
<span style="white-space:pre">	</span>Node *lchild;
<span style="white-space:pre">	</span>Node *parent;
<span style="white-space:pre">	</span>int weight;  //权值
<span style="white-space:pre">	</span>char ch;     //叶子字符
<span style="white-space:pre">	</span>char node_code;  //每个字符对应的路径（左0右1）
<span style="white-space:pre">	</span>Node(){};
};
class HuffmanTree
{
protected:
<span style="white-space:pre">	</span>Node *root;   //根节点
<span style="white-space:pre">	</span>vector<char> leaf_char;    //从叶节点得到字符
<span style="white-space:pre">	</span>vector<string>  leaf_code ;   //保存每个字符的编码
public:
<span style="white-space:pre">	</span>HuffmanTree(int p ,char c){root=new Node();root->weight=p;root->ch=c;}
<span style="white-space:pre">	</span>HuffmanTree(){root=new Node();}
<span style="white-space:pre">	</span>void build_tree(int pro[],char cha[],int count)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>HuffmanTree *r[26];
<span style="white-space:pre">		</span>for(int j=0;j<count;j++)     //初始化每个字符形成的树
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>r[j]=new HuffmanTree() ;
<span style="white-space:pre">			</span>r[j]->root->ch=cha[j];
<span style="white-space:pre">			</span>r[j]->root->weight=pro[j];
<span style="white-space:pre">			</span>
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>for(int j=0;j<count-1;j++)    //找出数组中根节点权值最小的两个 合并
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>for(int i=j+1;i<count;i++)      //找出最小权值的树放入r[j]
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>if(r[j]->root->weight>r[i]->root->weight)
<span style="white-space:pre">				</span>{
<span style="white-space:pre">					</span>HuffmanTree *temp;
<span style="white-space:pre">					</span>temp=r[i];
<span style="white-space:pre">					</span>r[i]=r[j];
<span style="white-space:pre">					</span>r[j]=temp;
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>for(int i=j+2;i<count;i++)     //找出最小权值的树放入r[j+1]
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>if(r[j+1]->root->weight>r[i]->root->weight)
<span style="white-space:pre">				</span>{
<span style="white-space:pre">					</span>HuffmanTree *temp;
<span style="white-space:pre">					</span>temp=r[i];
<span style="white-space:pre">					</span>r[i]=r[j+1];
<span style="white-space:pre">					</span>r[j+1]=temp;
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>HuffmanTree *t_r=new HuffmanTree();    //过渡用的t_r 生成新的树赋给r[j+1]
<span style="white-space:pre">			</span>t_r->root->lchild=r[j]->root;
<span style="white-space:pre">			</span>r[j]->root->parent=t_r->root;
<span style="white-space:pre">			</span>r[j]->root->node_code='0';      //是parent的左孩子，赋予路径0
<span style="white-space:pre">			</span>t_r->root->rchild=r[j+1]->root;
<span style="white-space:pre">			</span>r[j+1]->root->parent=t_r->root;
<span style="white-space:pre">			</span>r[j+1]->root->node_code='1';      //是parent的左孩子，赋予路径1
<span style="white-space:pre">			</span>t_r->root->weight = r[j]->root->weight+r[j+1]->root->weight;       //左右孩子的权值和
<span style="white-space:pre">			</span>r[j+1]=t_r;
<span style="white-space:pre">			</span>if(j+1==count-1)
<span style="white-space:pre">			</span>root=r[j+1]->root;
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>void turn_char_code(Node *h)      //输出每个字符的编码
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>string s;
<span style="white-space:pre">		</span>Node *temp=h;
<span style="white-space:pre">		</span>if(temp->lchild==NULL && temp->rchild==NULL)  //测到根节点
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>char c=temp->ch;
<span style="white-space:pre">			</span>leaf_char.push_back(temp->ch);
<span style="white-space:pre">			</span>while (temp->parent!=NULL)   //有父节点则推测哈夫曼编码
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>s=temp->node_code+s;
<span style="white-space:pre">				</span>temp=temp->parent;
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>leaf_code.push_back(s);
<span style="white-space:pre">			</span>cout<<c<<"的哈夫曼编码："<<s<<endl;


<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>if(h->lchild!=NULL)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>turn_char_code(h->lchild);
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>if(h->rchild!=NULL)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>turn_char_code(h->rchild);
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>string turn_string_code(string src)  //返回字符串的哈夫曼编码
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>string h_string;
<span style="white-space:pre">		</span>turn_char_code(root);
<span style="white-space:pre">		</span>for(int j=0;j<src.length();j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>for(int k=0;k<leaf_char.size();k++)
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>if(src[j]==leaf_char[k])
<span style="white-space:pre">				</span>h_string=h_string+leaf_code[k];
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>return h_string;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>string deCode(string src)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>string s;
<span style="white-space:pre">		</span>for(int j=0;j<src.length();)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>for(int k=0;k<leaf_char.size();k++)
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>int code_length=leaf_code[k].length();
<span style="white-space:pre">				</span>if(src.substr(j,code_length)==leaf_code[k])     //以j开头的code_length个字符为字串与leaf_code对比
<span style="white-space:pre">				</span>{
<span style="white-space:pre">					</span>s=s+leaf_char[k];
<span style="white-space:pre">					</span>j=j+code_length;
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>return s;
<span style="white-space:pre">	</span>}
};
string huffmancoding(const string &src)
{
<span style="white-space:pre">	</span>cout << "=========== Huffman coding ===========" << endl;
<span style="white-space:pre">	</span>cout << "Input string   : " << src << endl;


<span style="white-space:pre">	</span>string destCode;
<span style="white-space:pre">	</span>/// 在此处添加编码代码，输入为src，输出为destCode
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>int p[26]; 
<span style="white-space:pre">	</span>char c[26];
<span style="white-space:pre">	</span>c[0]=src[0];      
<span style="white-space:pre">	</span>  //字符串的各字符不重复地放入c[]
<span style="white-space:pre">		</span>int c_count=1;  //数组c[]的数量
<span style="white-space:pre">		</span>for(int j=0;j<src.length();j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>int k=0;
<span style="white-space:pre">			</span>for(k=0;k<c_count;k++)    //寻找当前的字符在c[]中是否有记录
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>if(c[k]==src[j])       //有记录则跳出循环 且k=0
<span style="white-space:pre">				</span>{
<span style="white-space:pre">					</span>k=0;
<span style="white-space:pre">					</span>break;
<span style="white-space:pre">				</span>}
<span style="white-space:pre">			</span>}
<span style="white-space:pre">			</span>if(k>0)         //在c[]中未找到当前字符
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>c_count++;
<span style="white-space:pre">				</span>c[c_count-1]=src[j];
<span style="white-space:pre">				</span>
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>  //计算src中各字符的出现次数 相对应记录于p[]
<span style="white-space:pre">		</span>for(int j=0;j<=c_count;j++)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>p[j]=0;
<span style="white-space:pre">			</span>for(int h=0;h<src.length();h++)
<span style="white-space:pre">			</span>{
<span style="white-space:pre">				</span>if(src[h]==c[j])
<span style="white-space:pre">					</span>p[j]++;
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}


<span style="white-space:pre">	</span>
<span style="white-space:pre">		</span>HuffmanTree h_tree;
<span style="white-space:pre">		</span>h_tree.build_tree(p,c,c_count);
<span style="white-space:pre">	</span>cout << "===== Code for each char :" << endl;<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>destCode=h_tree.turn_string_code(src);<span style="white-space:pre">			</span>
<span style="white-space:pre">	</span>cout << "Coded string   : " << destCode << endl;

<span style="white-space:pre">	</span><pre code_snippet_id="314458" snippet_file_name="blog_20140427_1_8226741" name="code" class="cpp"><span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space:pre">		</span>string destDecode;</span>

/// 此处输出每个字符的编码

/// 在此处添加解码代码，输入为destCode，输出为destDecode
destDecode=h_tree.deCode(destCode);
cout << "Decoded string : " << destDecode << endl;
return destDecode;
} 
 

 


                

        

        

    




    

      

        

            

              
                
                  Big_e_肥肠
                
              
            

            

                关注
              
            

        

        

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

      

      










                



	

		

			

				
					
哈夫曼函数

				
			

			

				

					m0_73679774的博客
				

				

					12-19
					
					175
					
				

			

		

		

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

例如，在英文中，e的出现机率最高，而z的出现概率则最低。当利用哈夫曼编码对一篇英文进行压缩时，e极有可能用一个比特来表示，而z则可能花去25个比特（不是26）。用普通的表示方法时，每个英文字母均占用一个字节，即8个比特。二者相

			
		

	



                

              
                



	

		

			

				
					
哈夫曼函数的简单程序实现

				
			

			

				

					zhangyuhe123456的博客
				

				

					12-21
					
					521
					
				

			

		

		

			
				
哈夫曼函数

			
		

	



                


  
              

                


	

		

			

				
					
Matlab 图像处理-哈夫曼编码（huffman）

				
			

			

				

					三哥的博客
				

				

					09-26
					
					5万+
					
				

			

		

		

			
				
哈夫曼编码是一种可变长无损编码，应用范围广。这里介绍利用matalb实现哈夫曼编码方法。matalb中带有相关函，下面一一介绍：ENCO = huffmanenco(SIG, DICT) : 哈夫曼编码函数，SIG为输入编码信号，DICT为编码字典，由函数huffmandict（）生成；DECO = huffmandeco(COMP, DICT) ：哈夫曼解码函数，COMP为哈夫曼编码向量，即上面的

			
		

	





	

		

			

				
					
4-4 哈夫曼编码

				
			

			

				

					tang7mj的博客
				

				

					06-04
					
					4967
					
				

			

		

		

			
				
哈夫曼编码（Huffman coding）是一种用于数据压缩的无损编码方法。它是由David A. Huffman在1952年提出的，被广泛应用于通信和存储领域。哈夫曼编码通过对不同符号赋予不同长度的编码，使得出现频率高的符号使用较短的编码，而出现频率低的符号使用较长的编码，以此来实现数据压缩。哈夫曼编码的关键思想是利用变长编码来表达符号，使得出现频率高的符号的编码比出现频率低的符号的编码更短，从而减少整体的编码长度。1. 统计符号的出现频率：遍历待编码的符号序列，统计每个符号出现的频率。

			
		

	



		

			
		



	

		

			

				
					
Huffman编码的Python与Matlab实现(附讲解)及编码效率与信源概率分布之间的关系

				
			

			

				

					DALEONE的博客
				

				

					06-23
					
					2147
					
				

			

		

		

			
				
借助于Matlab和python语言实现Huffman编码，并对Huffman编码的编码效率与信源概率分布之间的关系进行探索和验证，附详细代码和讲解过程

			
		

	





	

		

			

				
					
huffman编码

				
			

			

				

					wuyanzea的博客
				

				

					05-15
					
					4780
					
				

			

		

		

			
				
一.实验原理1.Huffman编码1)HuffmanCoding（霍夫曼编码）是一种无失真编码的编码方式，Huffman编码是可编长编码（VLC）的一种。 2)Huffman编码基于信源的概率统计模型，它的基本思路是：出现概率大的信源符号编短码，出现概率小的编长码。从而实现平均码长最小。 3)在程序实现中常使用一种叫做树的数据结构实现Huffman编码，由它编出的码是即时码。2.Huffman编码...

			
		

	





	

		

			

				
					
huffman 编码

				
			

			

				

					zzran的专栏
				

				

					07-25
					
					2714
					
				

			

		

		

			
				
huffman压缩是一种压缩算法，其中经典的部分就是根据字符出现的频率建立huffman树，然后根据huffman树的构建结果标示每个字符。huffman编码也称为前缀编码，就是每个字符的表示形式不是另一个字符表示的前缀。如果学过c语言版本的数据结构的话，那么会知道其上面的算法的时间复杂度是O(N^2)， 也算是比较复杂的，那么首先贴上这个版本算法的代码：
#include
#include
u

			
		

	





	

		

			

				
					
基于Matlab的图像Huffman编码的实现

				
			

			

				

					12-27
				

			

		

		

			
				
然后，构建Huffman树，Matlab虽然没有内置的Huffman编码函数，但可以通过自定义算法实现。这通常涉及构造最小堆和合并节点的过程，直到只剩下一个根节点，此时得到的树结构就是Huffman树。  编码过程是从根节点开始...

			
		

	





	

		

			

				
					
huffman编码_编码_Huffman编码_huffman_

				
			

			

				

					10-02
				

			

		

		

			
				
在给定的文件"final"中，可能包含了实现Huffman编码和解码的代码，包括编码函数和解码函数。编码函数会接收字符集和频率作为输入，生成Huffman树并输出编码表；解码函数则会使用这个编码表来解析编码后的数据，恢复...

			
		

	





	

		

			

				
					
Huffman编码C++实现

				
			

			

				

					11-17
				

			

		

		

			
				
Huffman编码是一种高效的数据压缩算法，它基于字符频率构建最小带权路径长度的二叉树。在C++中实现Huffman编码需要理解以下几个关键概念：  1. **字符频率统计**：首先，我们需要统计输入文本中各个字符出现的频率。...

			
		

	





	

		

			

				
					
huffman函数

				
			

			

				

					08-04
				

			

		

		

			
				
huffman压缩编码
function CODE =huffman(p) 
error(nargchk(1,1,nargin));
if (ndims(p)~=2) ||(min(size(p))>1)||~isreal(p)||~isnumeric(p)
   error('P must be a real numeric vector.'); 
end 
global CODE
CODE=cell(length(p),1);
if length(p)>1
    p=p/sum(p);
    s=reduce(p);
    makecode(s,[]);
else
    CODE={'1'};
end

			
		

	





	

		

			

				
					
利用matlab自带函数huffmandict 编写哈夫曼码

				
			

			

				

					05-22
				

			

		

		

			
				
利用matlab自带函数huffmandict() 写的哈夫曼码。可修改数组长度；利用随机数生成每个元素的概率。

			
		

	





	

		

			

				
					
用matlab自编算数编码 哈夫曼编码函数

				
			

			

				

					12-26
				

			

		

		

			
				
用matlab自编算数编码 哈夫曼编码函数

			
		

	





	

		

			

				
					
huffman code.zip_huffman_二元Huffman编码

				
			

			

				

					07-14
				

			

		

		

			
				
本压缩包文件"**huffman code.zip_huffman_二元Huffman编码**"是关于二元霍夫曼编码的实践教程，通过MATLAB语言实现。下面我们将深入探讨二元霍夫曼编码及其MATLAB实现的关键知识点。  首先，二元霍夫曼编码是一种变...

			
		

	





	

		

			

				
					
Huffman编码树通过MATLAB实现

				
			

			

				

					03-18
				

			

		

		

			
				
Huffman编码是一种高效的数据压缩算法，它基于一种称为Huffman树（或Huffman编码树）的数据结构。在MATLAB环境中实现Huffman编码树，可以让我们更深入地理解该算法的工作原理，并能应用于实际的文件压缩。  首先，...

			
		

	





	

		

			

				
					
哈夫曼树及哈夫曼编码详解【完整版代码】

					
热门推荐

				
			

			

				

					wardseptember的博客
				

				

					06-17
					
					11万+
					
				

			

		

		

			
				
Huffman Tree简介&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,…,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,…,wn}，则所构造出的带权路径长度最小的二叉树就被称为赫夫曼树。&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;a

			
		

	





	

		

			

				
					
huffman编码实现（详细实现）

				
			

			

				

					
				

				

					08-05
					
					4万+
					
				

			

		

		

			
				
1、概述
 
huffman编码是一种可变长编码（ VLC：variable length coding)）方式，于1952年由huffman提出。依据字符在需要编码文件中出现的概率提供对字符的唯一编码，并且保证了可变编码的平均编码最短，被称为最优二叉树，有时又称为

			
		

	





	

		

			

				
					
哈夫曼编码图像压缩Matlab

				
			

			

				

					cxcx2001的博客
				

				

					07-05
					
					6182
					
				

			

		

		

			
				
哈夫曼编码图像压缩Matlab

			
		

	





	

		

			

				
					
编写一个基于matlab的huffman编码函数

					
最新发布

				
			

			

				

					06-06
				

			

		

		

			
				
好的，以下是一个基于Matlab的Huffman编码函数的代码实现：

```matlab
function [encoded, dict] = huffman_encode(text)
% 计算字符出现频率
freq = histcounts(text, unique(text));
% 构建Huffman树
symbols = transpose(unique(text));
dict = huffmandict(symbols, freq);
% 对文本进行编码
encoded = huffmanenco(text, dict);
end
```

这个函数接受一个字符串作为输入，然后计算字符出现频率、构建Huffman树，并对文本进行编码。函数的输出包括编码后的比特流和Huffman编码字典。

在函数中，我们使用Matlab内置的`histcounts`函数来计算字符出现频率，使用`huffmandict`函数来构建Huffman树，使用`huffmanenco`函数来对文本进行编码。最终，我们将编码后的比特流和Huffman编码字典作为函数的输出返回。

你可以将这个函数保存为一个.m文件，然后在Matlab命令窗口中调用它来进行Huffman编码。例如：

```matlab
text = 'hello world';
[encoded, dict] = huffman_encode(text);
```

这样就可以得到`encoded`和`dict`两个变量，分别存储编码后的比特流和Huffman编码字典。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值