模拟编码译码(huffman编码应用)

最新推荐文章于 2022-06-07 23:56:00 发布
最新推荐文章于 2022-06-07 23:56:00 发布
阅读量1.6k 收藏 1
点赞数 2
分类专栏： Data Structure 文章标签： file ios string struct encoding class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkay_wong/article/details/7019216
版权

用huffman编码对一些字符进行编码，然后再将用户输入的桔子进行编码，还有译码等。一个huffman 编码的小应用

文件"huffman.h"

#include <iostream>
#include <string>
#include <fstream>
using namespace std;

//栈模版
template<class T>
class My_stack;

template<class T>
class Node		//结点类
{
private:
	T data;
	Node<T> *next;
public:
	Node()
	{
		next=NULL;
	}
	Node(T d)
	{
		data=d;
		next=NULL;
	}
	friend My_stack<T>;
};

template<class T>
class My_stack
{
private:
	Node<T> *head;
public:
	My_stack()
	{
		head=new Node<T>();
	}
	
	~My_stack()
	{
		clean();
		delete head;
	}
	
	bool empty() const
	{
		return (head->next==0);
	}
	
	void push(T d)	//入栈
	{
		Node<T> *p=new Node<T>(d);
		p->next=head->next;
		head->next=p;
	}
	
	T top()	//返回栈顶元素
	{
		if(empty())
		{
			cout<<"stack is empty."<<endl;
			exit(1);
		}
		Node<T> *p=head->next;
		T temp=p->data;
		return temp;
	}
	
	void pop()	//弹出栈顶元素
	{
		Node<T> *p=head->next;
		head->next=p->next;
		delete p;
	}
	
	void clean()	//清除整个栈
	{
		Node<T> *p=head->next;
		while(p)
		{
			head->next=p->next;
			delete p;
			head->next=p;
		}
	}
};

//临时结点结构，存放哈夫曼树的结点名称和数据
struct temp_node
{
	char name;
	int data;
};

//临时结点结构，用于存放编码后的结点名称和数据
struct EnCo_Node
{
	char name;
	string data;
};

class HuffmanTree;

class HuffmanNode
{
private:
	char name;
	int data;
	int parent,lchild,rchild;
	friend HuffmanTree;
};

class HuffmanTree
{
public:
	void Create_HuffmanTree(HuffmanNode *&HT,temp_node w[],int n)
	{
		//用w申请的数组暂时保存权值（暂时设定全都大于0）
		if(n<1)
		{
			cout<<"参数不合理"<<endl;
			return ;
		}
		
		int m=2*n-1; //n个叶子结点的哈夫曼树总共有2*n-1个结点
		
		HT=new HuffmanNode[m]; //分配m个huffman结点
		
		int i,k,lnode,rnode;
		double min1,min2; //存放两个最小的结点值
		for(i=0;i<n;i++)
		{
			HT[i].name=w[i].name;
			HT[i].data=w[i].data;
			HT[i].lchild=-1;
			HT[i].rchild=-1;
			HT[i].parent=-1;
		}
		for(int j=i;j<m;j++)
		{
			HT[j].name='#';
			HT[j].data=0;
			HT[j].lchild=-1;
			HT[j].rchild=-1;
			HT[j].parent=-1;
		}
		//结点初始化完成，下面开始构造huffman树	
		for(i=n;i<2*n-1;i++)
		{		
			min1=min2=32767;
			lnode=rnode=-1;
			for(k=0;k<=i-1;k++)
			{
				if(-1 == HT[k].parent)
				{
					if(HT[k].data<min1)
					{
						min2=min1;
						rnode=lnode;
						min1=HT[k].data;
						lnode=k;
					}
					else if(HT[k].data<min2)
					{
						min2=HT[k].data;
						rnode=k;
					}
				}
			}
			HT[i].data=min1+min2;
			HT[i].lchild=lnode;
			HT[i].rchild=rnode;
			HT[lnode].parent=i;
			HT[rnode].parent=i;
		}
		cout<<"____huffman树构造完成____"<<endl;
	}

	void Huffman_Coding(HuffmanNode *HT,int n)
	{
		//对结点进行哈夫曼编码
		ofstream file;
		HuffmanNode *q;
		int f,temp,p,a[20],t;
		My_stack<int> s;
		file.open("hfmTree.txt");
		for(int i=0;i<n;i++)
		{	
			t=0;
			q=HT;
			f=i;
			p=q[f].parent;
			while(p!=-1)
			{
				if(q[p].lchild==f)
					temp=0;
				else
					temp=1;
				s.push(temp);
				f=p;
				p=q[p].parent;
			}
			cout<<"第"<<i+1<<"个字符 "<<HT[i].name<<" 的huffman编码为：";
			while(!s.empty())
			{
				cout<<s.top()<<" ";
				a[t]=s.top();
				t++;
				s.pop();
			}
			//将各个字符的编码存入指定文件中
			Save_Code(a,t,HT[i].name);
			cout<<endl;
		}
		file.close();
		cout<<"编码完成,并已保存到\"hfmTree.txt\"文件中"<<endl;
	}

	//保存每一个编码到hfmTree文件中
	void Save_Code(int a[],int n,char name)
	{
		ofstream file;
		file.open("hfmTree.txt",ios::app);
		file<<endl<<name<<"   ";
		for(int i=0;i<n;i++)
			file<<a[i];
		file.close();
	}

	bool EnCoding(const char *p,int n)
	{
		//编码函数,对字符串进行编码，然后保存到指定文件
		fstream file1,file2;
		string Aim_Code[100];
		int i,sum=0;
		string temp_c;

		file1.open("hfmTree.txt",ios::in);
		if(!file1)
		{
			cerr<<"文件\"hfmTree.txt\"打开失败"<<endl;
			return false;
		}

		EnCo_Node node[30];
		for(i=0;i<30;i++)
			node[i].data="32767";

		while(!file1.eof())
		{
			file1>>node[sum].name>>node[sum].data;
			sum++;
		}
		file1.close();

		i=0;
		sum=0;
		while(p[i] != '\0')
		{
			if(p[i] == '*')
				temp_c=node[n-1].data;
			else
				temp_c=node[ p[i] - 'A' ].data;
			if(temp_c == "32767" )
				cout<<"字符 "<<p[i]<<" 没有编码,在编码文件中将不会有该字符的编码"<<endl;
			else
			{
				Aim_Code[sum]=temp_c;
				sum++;
			}
			i++;
		}
		
		file2.open("CodeFile.txt",ios::out);
		if(!file2)
		{
			cerr<<"文件\"CodeFile.txt\"打开失败"<<endl;
			return false;
		}
		for(int j=0;j<sum;j++)
			file2<<endl<<Aim_Code[j];
		file2.close();
	
		return true;
	}

	bool Decoding()
	{
		//译码函数,将文件CodeFile.txt中的编码进行编译，还原成原来的意思
		int i,j,Code_sum,Aim_sum;
		fstream file1,file2,file3;
		file1.open("hfmTree.txt",ios::in);
		if(!file1)
		{
			cerr<<"文件\"hfmTree.txt\"打开失败"<<endl;
			return false;
		}

		EnCo_Node node[30];
		Code_sum=0;
		while(!file1.eof())
		{
			file1>>node[Code_sum].name>>node[Code_sum].data;
			Code_sum++;
		}
		
		file1.close();

		file2.open("CodeFile.txt",ios::in);
		if(!file2)
		{
			cerr<<"文件\"CodeFile.txt\"打开失败"<<endl;
			return false;
		}

		string Aim_Code[100];
		Aim_sum=0;
		while(!file2.eof())
		{
			file2>>Aim_Code[Aim_sum];
			Aim_sum++;
		}
		file2.close();

		file3.open("TextFile.txt",ios::out);
		if(!file3)
		{
			cerr<<"文件\"TextFile.txt\"打开失败"<<endl;
			return false;
		}

		for(i=0;i<Aim_sum;i++)
		{
			for(j=0;j<Code_sum;j++)
			{
				if(node[j].data == Aim_Code[i])
				{
					if(node[j].name == '*')
					{
						//cout<<" ";
						file3<<" ";
					}
					else
					{
						//cout<<node[j].name;
						file3<<node[j].name;
					}
				}
			}
		}
		file3.close();

		return true;
	}

	bool Show_Code()
	{
		//紧凑形式显示编码,并存入文件
		int Code_sum,i;
		int Aim_Code[100];
		char p[256];
		fstream file1,file2,file3;
		file1.open("CodeFile.txt",ios::in);
		if(!file1)
		{
			cerr<<"文件\"CodeFile.txt\"打开失败"<<endl;
			return false;
		}

		Code_sum=0;
		while(!file1.eof())
		{
			file1>>Aim_Code[Code_sum];
			Code_sum++;
		}
		file1.close();

		file2.open("CodePrin.txt",ios::out);
		if(!file2)
		{
			cerr<<"文件\"CodePrin.txt\"打开失败"<<endl;
			return false;
		}
		
		for(i=0;i<Code_sum;i++)
			file2<<Aim_Code[i];
		file2.close();

		file2.open("CodePrin.txt",ios::in);
		if(!file2)
		{
			cerr<<"文件\"CodePrin.txt\"打开失败"<<endl;
			return false;
		}
		
		i=0;
		while(!file2.eof())
		{
			file2>>p[i];
			i++;
		}
		file2.close();

		for(int j=0;j<i;j++)
		{
			cout<<p[j];
			if(j>0 && j%49 == 0)
				cout<<endl;
		}
		cout<<endl;

		file3.open("CodePrin.txt",ios::out);
		if(!file3)
		{
			cerr<<"文件\"CodePrin.txt\"打开失败"<<endl;
			return false;
		}

		for(j=0;j<i;j++)
		{
			file3<<p[j];
			if(j>0 && j%49 == 0)
				file3<<endl;
		}
		file3.close();
		return true;
	}

	void Print_Trees(HuffmanNode *HT,int m,int n,int base,int dep)
	{
		//凹入形式显示哈夫曼树
		if(dep>0)
		{
			ofstream file("TreePrint.txt",ios::app);
			int b=base-dep;
			for(int i=b;i>0;i--)
			{
				cout<<"   ";
				file<<"   ";
			}
			cout<<HT[m-1].data<<endl;
			file<<HT[m-1].data<<endl;
			file.close();
			if(m>n)
			{
				Print_Trees(HT,HT[m-1].lchild+1,n,base,dep-1);
				Print_Trees(HT,HT[m-1].rchild+1,n,base,dep-1);
			}
		}
	}
};
主函数： 

#include "huffman.h"
#include <fstream>
#include <string>
#include <iostream>
using namespace std;

int main()
{
	int flag,n=0,i,m=0,dep;
	long pos;
	temp_node *p;
	HuffmanTree tree;
	HuffmanNode *HT;
	fstream file1,file2;
	do
	{
		cout<<"输入你的选择："<<endl;
		cout<<"*********************************************"<<endl;
		cout<<"* 1:初始化         2:哈夫曼编码     3:译码  *"<<endl;
		cout<<"* 4:印编码文件     5:印哈夫曼树     6:退出  *"<<endl;
		cout<<"*********************************************"<<endl;
		cin>>flag;
		switch(flag)
		{
		case 1:
			n=0;
			p=new temp_node[30];
			file1.open("TreeData.txt",ios::in);
			if(!file1)
			{
				cerr<<"文件\"TreeData.txt\"打开失败"<<endl;
				exit(1);
			}
			cout<<"从文件\"TreeData.txt\"读入数据初始化"<<endl;
			while(!file1.eof())
			{
				file1>>p[n].name>>p[n].data;
				n++;
			}
			cout<<endl;
			tree.Create_HuffmanTree(HT,p,n);
			cout<<"__________huffman编码_____________并显示编码________"<<endl;
			file1.open("hfmTree.txt",ios::out);
			tree.Huffman_Coding(HT,n);
			cout<<endl;
			break;
		case 2:	
			file1.open("hfmTree.txt",ios::in);
			file1.seekg(0,ios::end);
			pos=file1.tellg();
			if(!pos)
				cout<<"哈夫曼树不存在,请先初始化哈夫曼树"<<endl;
			else
			{
				//编码
				cout<<"输入你要进行编码的字符串(空格用'*'代替)：";
				string target;
				cin>>target;
				const char *ch=target.data();
				//调用译码函数
				if(tree.EnCoding(ch,n))
					cout<<"编码完成，编码结果已经存入\"CodeFile.txt\"文件中"<<endl;
			}
			file1.close();
			break;
		case 3:
            //译码
			file1.open("CodeFile.txt",ios::in);
			file1.seekg(0,ios::end);
			pos=file1.tellg();
			if(!pos)
				cout<<"待编码文件不存在，请重新进行编码，再选择译码操作"<<endl;
			else
			{
				if(tree.Decoding())
					cout<<"译码成功，译码结果已存放在文件\"TextFile.txt\"中"<<endl;
			}
			file1.close();
			break;
		case 4:
			//印编码
			file2.open("CodeFile.txt",ios::in);
			file2.seekg(0,ios::end);
			pos=file2.tellg();
			if(!pos)
				cout<<"该文件不存在，请重新进行编码，再选择此操作"<<endl;
			else
			{
				if(tree.Show_Code())
					cout<<"显示完成"<<endl;
			}
			break;
		case 5:
			cout<<"显示哈夫曼树中数据的结构,只显示权值的组成结构"<<endl;
			m=2*n-1;
			dep=m-n;
			file1.open("TreePrint.txt",ios::out);
			tree.Print_Trees(HT,m,n,m-n,dep);
			file1.close();
			cout<<endl;
			break;
		case 6:
			cout<<"谢谢使用，88"<<endl;
			break;
		default:
			cout<<"选择无效，重新选择"<<endl;
			break;
		}
	}while(flag != 6);

	return 0;
}
测试结果： 

输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
1
从文件"TreeData.txt"读入数据初始化

____huffman树构造完成____
__________huffman编码_____________并显示编码________
第1个字符 A 的huffman编码为：1 0 1 0
第2个字符 B 的huffman编码为：1 0 0 0 0 0
第3个字符 C 的huffman编码为：0 0 0 0 0
第4个字符 D 的huffman编码为：1 0 1 1 0
第5个字符 E 的huffman编码为：0 1 0
第6个字符 F 的huffman编码为：1 1 0 0 1 1
第7个字符 G 的huffman编码为：1 0 0 0 0 1
第8个字符 H 的huffman编码为：0 0 0 1
第9个字符 I 的huffman编码为：0 1 1 0
第10个字符 J 的huffman编码为：1 1 0 0 0 0 1 0 0 0
第11个字符 K 的huffman编码为：1 1 0 0 0 0 1 1
第12个字符 L 的huffman编码为：1 0 1 1 1
第13个字符 M 的huffman编码为：1 1 0 0 1 0
第14个字符 N 的huffman编码为：0 1 1 1
第15个字符 O 的huffman编码为：1 0 0 1
第16个字符 P 的huffman编码为：1 0 0 0 1 0
第17个字符 Q 的huffman编码为：1 1 0 0 0 0 1 0 0 1
第18个字符 R 的huffman编码为：0 0 1 0
第19个字符 S 的huffman编码为：0 0 1 1
第20个字符 T 的huffman编码为：1 1 0 1
第21个字符 U 的huffman编码为：0 0 0 0 1
第22个字符 V 的huffman编码为：1 1 0 0 0 0 0
第23个字符 W 的huffman编码为：1 1 0 0 0 1
第24个字符 X 的huffman编码为：1 1 0 0 0 0 1 0 1 0
第25个字符 Y 的huffman编码为：1 0 0 0 1 1
第26个字符 Z 的huffman编码为：1 1 0 0 0 0 1 0 1 1
第27个字符 * 的huffman编码为：1 1 1
编码完成,并已保存到"hfmTree.txt"文件中

输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
2
输入你要进行编码的字符串(空格用'*'代替)：
CSDN*BLOG*KAYSPRINT*COME*ON
编码完成，编码结果已经存入"CodeFile.txt"文件中
输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
3
译码成功，译码结果已存放在文件"TextFile.txt"中
输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
4
01110110111111100000101111001100001111110000111010
1000111110001010110111110111101001110010101111001
111
显示完成
输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
5
显示哈夫曼树中数据的结构,只显示权值的组成结构
1000
   408
      191
         92
            45
               22
               23
            47
         99
            48
            51
      217
         103
         114
            57
            57
   592
      250
         122
            59
               28
                  13
                  15
               31
                  15
                  16
            63
         128
            64
            64
               32
               32
      342
         156
            76
               35
                  17
                     8
                     9
                        4
                           2
                              1
                              1
                           2
                              1
                              1
                        5
                  18
               41
                  20
                  21
            80
         186

输入你的选择：
*********************************************
* 1:初始化         2:哈夫曼编码     3:译码  *
* 4:印编码文件     5:印哈夫曼树     6:退出  *
*********************************************
6
谢谢使用，88
Press any key to continue
程序中的编码，数据，译码等数据都是保存在指定文件中，对文件流操作可以做点复习。



JKay_Wong
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
哈夫曼编码译码(HuffmanCode)
06-14
哈夫曼 编码 译码win-tc
huffman编码译码的matlab仿真
FPGA/MATLAB学习教程/源码/项目合作开发
04-20 4517
1.问题描述： 哈夫曼树介绍 　　哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL=(W1*L1+W2*L2+W3*L3+...+ Wn*Ln)，N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,...n)。可以证明哈夫曼树的WPL是最小的。 利用哈夫曼编码进行通信可以...
贪心——新田忌赛马
linjiayina的博客
01-20 422
贪心——新田忌赛马 题目描述 田忌和齐威王又开始赛马了，这一次齐威王为了增加难度，在每一匹马上都设置了一个刀币值，如果田忌赢了这匹马，那么他就可以获得相应的刀币，否则他就要失去相应的刀币（平局田忌也要失去刀币）。现在齐威王和田忌各有n匹马，每匹马有一个速度值，齐威王的每匹马还有一个刀币值，速度快的马会获得胜利，速度相同则是平局。现在齐威王已经排好了马的顺序，请你帮助田忌排兵布阵，并计算出他最多可以...
哈夫曼编码实验
qq_62434736的博客
06-07 549
从一文件中读取字符，统计该文件中各个字符（如abc…等26个字符）出现的概率，根据各自的概率为权值，为这些字符建立一颗哈夫曼树，并对每个字符进行哈夫曼编码和哈夫曼解码。要求具有较好的变量命名和较好人机交互处理过程。......
Huffman树进行编码和译码
weixin_33842304的博客
04-28 218
//编码 #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> #include<algorithm> #include<queue> #include<fstream> #inc...
exp2_huffman_Huffman编码译码_哈夫曼编码/译码_
09-29
给定一段哈夫曼编码，按照编码规则在哈夫曼树上进行模拟，从根节点出发，遇到0向左分支移动，遇到1向右分支移动。当到达叶子节点时，对应的字符就是编码所表示的原始字符。 4. **编程实现**： - 在MATLAB环境中，...
哈弗曼树的编码和译码（C++版）
07-06
哈弗曼树（Huffman Tree），也称为最优二叉树，是数据压缩中的一种关键算法，主要用于实现哈弗曼编码（Huffman Coding）。哈弗曼编码是一种基于字符出现频率的变长编码方式，旨在减少数据的存储空间，提高传输效率。...
分享MATLAB霍夫曼Huffman编码译码GUI界面设计源程序代码-MATLAB霍夫曼Huffman编码译码GUI界面设计 源程序代码.rar
08-12
霍夫曼编码（Huffman Coding）是一种高效的数据压缩方法，由D.W. Huffman在1952年提出，它基于字符出现频率进行编码，常用于文本压缩。MATLAB作为一款强大的数学计算软件，也支持编写图形用户界面（GUI）程序，使得...
霍夫曼树实现编码解码C语言实现
10-18
霍夫曼树（Huffman Tree），也称为最优二叉树，是数据压缩技术中的关键工具，主要用于构建霍夫曼编码。这种编码方法基于字符出现频率，频繁出现的字符赋予较短的编码，不常出现的字符则赋予较长的编码，以此达到数据...
模拟赫夫曼编/译码器
08-22
赫夫曼编码是一种高效的数据压缩算法，由大卫·赫夫曼在1952年提出。它是基于贪心策略的二叉树构造方法，主要用于文本数据的压缩。...对于理解赫夫曼编码的工作原理和实际应用，这是一个很好的学习实例。
哈夫曼编码的贪心算法设计
04-30
它用C语言详细地介绍了哈弗曼编码的贪心算法的设计步骤及数据描述。
哈弗曼编码译码器 Huffman译码器
07-18
输入字符 自己求频率 建立Huffman树 编码译码
哈夫曼编码（Huffman Coding）多图详细解析
热门推荐
Demon_LMMan的博客
04-17 3万+
哈夫曼编码 哈夫曼编码，又称为霍夫曼编码，它是现代压缩算法的基础。假如我们需要将字符串ABBBCCCCCCCCDDDDDDEE通过二进制编码进行传输，那应该怎么将字符转换为二进制码？ 方法一：转换为ASCII码 直接将字母转换为对应的ASCII码数字，再将ASCII码转换为对应的二进制码 字母 ASCII码 二进制码 A 65 100 0001 B 66 100 0010 C 67 100 0011 D 68 100 0100 E 69 100 0101 显然这样的方式使
哈夫曼树，哈夫曼编码及解码详解
princekin
05-18 8446
给定报文中26个字母a-z及空格的出现频率{64, 13, 22, 32, 103, 21, 15, 47, 57, 1, 5, 32, 20, 57, 63, 15, 1, 48, 51, 80, 23, 8, 18, 1, 16, 1, 168}，构建哈夫曼树并为这27个字符编制哈夫曼编码，并输出。模拟发送端，从键盘输入字符串，以%为结束标记，在屏幕上输出输入串的编码；模拟接收端，从键盘上输入0-1哈夫曼编码串，翻译出对应的原文。
Huffman树及Huffman编码，译码的算法实现
Wood_Du的博客
05-18 1万+
参考：https://blog.csdn.net/curson_/article/details/53771386 本来以为这个实验一会儿就可以搓出来，最后跟着要求搓了几个小时，菜是原罪，菜是真的菜，（助教小姐姐很好） 要求： 1、输入一段100—200字的英文短文，存入一文件a中。 2、写函数统计短文出现的字母个数n及每个字母的出现次数 3、写函数以字母出现次数作权值，建Haffman...
C语言实现哈夫曼编码
Allureyou的博客
01-10 3856
#include #define n5 //叶子数目 #define m(2*n-1) //结点总数 #define maxval 10000.0 #define maxsize100 //哈夫曼编码的最大位数 typedef struct { char ch; float weight; int lchild,rchild,parent; }hufmtree; typedef
霍夫曼编码最简单的实现
u013915688的博客
09-05 2811
    前两天发布那个rsync算法后，想看看数据压缩的算法，知道一个经典的压缩算法Huffman算法。相信大家应该听说过 David Huffman 和他的压缩算法—— Huffman Code，一种通过字符出现频率，Priority Queue，和二叉树来进行的一种压缩算法，这种二叉树又叫Huffman二叉树 —— 一种带权重的树。从学校毕业很长时间的我忘了这个算法，但是网上查了一下，中文社区...
游程编码和Huffman编码
chengyangyy的专栏
09-08 2912
#include <iostream> #include <stdio.h> using namespace std;string RunLengthEncoding(string str){ int size = str.size(); if(size <= 0){ return ""; }//if string result(str.substr(
信源编码：huffman编码
kaithdoble的博客
07-08 2457
1.对omaha.img、sensin.img以及sena.img三个文件先使用MATLAB编程求相邻像素之差，对差值进行Huffman编码以及解码。得到以下的的结果。                                    可以看出，用huffman编码进行压缩时,符号概率分布越不均匀，信源压缩效果越好。进行差分处理后，各个文件的信源符号分布概率成拉普
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值