哈夫曼编码算法_范文大全

哈夫曼编码算法

【范文精选】哈夫曼编码算法

【范文大全】哈夫曼编码算法

【专家解析】哈夫曼编码算法

【优秀范文】哈夫曼编码算法

问题一:哈夫曼编码的算法代码

// 哈夫曼编码(算法)#include

#include

#include typedef char *HuffmanCode; //动态分配数组,存储哈夫曼编码typedef struct

{

unsigned int weight; //用来存放各个结点的权值

unsigned int parent,LChild,RChild; //指向双亲、孩子结点的指针

} HTNode, *HuffmanTree; //动态分配数组,存储哈夫曼树//选择两个parent为0,且weight最小的结点s1和s2

void Select(HuffmanTree *ht,int n,int *s1,int *s2)

{

int i,min;

for(i=1; i<=n; i++)

{

if((*ht)[i].parent==0)

{

min=i;

break;

}

}

for(i=1; i<=n; i++)

{

if((*ht)[i].parent==0)

{

if((*ht)[i].weight<(*ht)[min].weight)

min=i;

}

}

*s1=min;

for(i=1; i<=n; i++)

{

if((*ht)[i].parent==0 && i!=(*s1))

{

min=i;

break;

}

}

for(i=1; i<=n; i++)

{

if((*ht)[i].parent==0 && i!=(*s1))

{

if((*ht)[i].weight<(*ht)[min].weight)

min=i;

}

}

*s2=min;

}//构造哈夫曼树ht。w存放已知的n个权值

void CrtHuffmanTree(HuffmanTree *ht,int *w,int n)

{

int m,i,s1,s2;

m=2*n-1;

*ht=(HuffmanTree)malloc((m+1)*sizeof(HTNode));

for(i=1; i<=n; i++) //1--n号存放叶子结点,初始化

{

(*ht)[i].weight=w[i];

(*ht)[i].LChild=0;

(*ht)[i].parent=0;

(*ht)[i].RChild=0;

}

for(i=n+1; i<=m; i++)

{

(*ht)[i].weight=0;

(*ht)[i].LChild=0;

(*ht)[i].parent=0;

(*ht)[i].RChild=0;

} 绩/非叶子结点初始化

printf("\nHuffmanTree: \n");

for(i=n+1; i<=m; i++) //创建非叶子结点......余下全文>>

问题二:哈夫曼编码算法的实现

在网上看到一个,刚好用到,我试过的,正确

#include

#include

#include

#include

#include

using namespace std;

typedef struct {

unsigned int weight;

char ch1;

unsigned int parent,lchild,rchild;

}HTNode,*HuffmanTree;

typedef char **HuffmanCode;

typedef struct {

char ch;

char code[7];

}codenode,*code;

void select(HuffmanTree HT,int n,int & s1,int &s2){ //从哈夫曼树中选择出最小的两个节点

for(int i=1;i<=n;i++)

if(!HT[i].parent){

s1=i; break;

}

for(i++;i<=n;i++)

if(!HT[i].parent){

s2=i; break;

}

if(HT[s1].weight-HT[s2].weight){

int temp; temp=s1; s1=s2; s2=temp;

}

for(i=1;i<=n;i++) //对数组进行遍历,寻找最小的两个节点

if(!HT[i].parent){

if(HT[i].weight

s2=s1; s1=i;

}

else if(HT[i].weight

s2=i;

}

}

void prin(){ //终端输出选择菜单

cout<<"----------------------------------------------------\n\n"

<<" ∣ I---创建哈夫曼树 ∣\n"

<<" ∣ ∣\n"

<<" ∣ E---文件编码 ∣\n"

<<" ∣ ∣\n"

<<" ∣ D---文件译码 ∣\n"

<<" ∣ ∣\n"

<<" ∣ P---打印代码文件 ∣\n"

<<" ∣ ∣\n"

<<" ∣ T---印哈夫曼树 ∣\n"

<<" ∣ ∣\n"

<<" ∣ O---哈夫曼树的存储结构 ∣\n"

<<" ∣ ∣\n"

<<" ∣ Q---退出 ∣\n"

<<"\n----------------------------------......余下全文>>

问题三:哈夫曼编码 数据结构算法

#include

#include

#define N 50 /*叶子结点数*/

#define M 2*N-1 /*树中结点总数*/

typedef struct

{

char data[5]; /*结点值*/

int weight; /*权重*/

int parent; /*双亲结点*/

int lchild; /*左孩子结点*/

int rchild; /*右孩子结点*/

} HTNode;

typedef struct

{

char cd[N]; /*存放哈夫曼码*/

int start;

} HCode;

void CreateHT(HTNode ht[],int n)

{

int i,k,lnode,rnode;

int min1,min2;

for (i=0;i<2*n-1;i++) /*所有结点的相关域置初值-1*/

ht[i].parent=ht[i].lchild=ht[i].rchild=-1;

for (i=n;i<2*n-1;i++) /*构造哈夫曼树*/

{

min1=min2=32767; /*lnode和rnode为最小权重的两个结点位置*/

lnode=rnode=-1;

for (k=0;k<=i-1;k++)

if (ht[k].parent==-1) /*只在尚未构造二叉树的结点中查找*/

{

if (ht[k].weight

{

min2=min1;rnode=lnode;

min1=ht[k].weight;lnode=k;

}

else if (ht[k].weight

{

min2=ht[k].weight;rnode=k;

}

}

ht[lnode].parent=i;ht[rnode].parent=i;

ht[i].weight=ht[lnode].weight+ht[rnode].weight;

ht[i].lchild=lnode;ht[i].rchild=rnode;

}

}

void CreateHCode(HTNode ht[],HCode hcd[],int n)

{

int i,f,c;

HCode hc;

for (i=0;i

{

hc.start=n;c=i;

f=ht[i].parent;

while (f!=-1) /*循序直到树根结点*/

{

if (ht[f].lchild==c) /*处理左孩子结点*/

hc.cd[hc.start--]='0';

else /*处理右孩子结点*/

hc.cd[hc.start--]='1';

c=f;f=ht[f].parent;

}

hc.start++; /*start指向哈夫曼编码最开始字符*&#......余下全文>>

问题四:哈夫曼编码原理

霍夫曼(Huffman)编码属于码词长度可变的编码类,是霍夫曼在1952年提出的一种编码方法,即从下到上的编码方法。同其他码词长度可变的编码一样,可区别的不同码词的生成是基于不同符号出现的不同概率。生成霍夫曼编码算法基于一种称为“编码树”(coding tree)的技术。算法步骤如下:

(1)初始化,根据符号概率的大小按由大到小顺序对符号进行排序。

(2)把概率最小的两个符号组成一个新符号(节点),即新符号的概率等于这两个符号概率之和。

(3)重复第2步,直到形成一个符号为止(树),其概率最后等于1。

(4)从编码树的根开始回溯到原始的符号,并将每一下分枝赋值为1,上分枝赋值为0。

以下这个简单例子说明了这一过程。

1).字母A,B,C,D,E已被编码,相应的出现概率如下:

p(A)=0.16, p(B)=0.51, p(C)=0.09, p(D)=0.13, p(E)=0.11

2).C和E概率最小,被排在第一棵二叉树中作为树叶。它们的根节点CE的组合概率为0.20。从CE到C的一边被标记为1,从CE到E的一边被标记为0。这种标记是强制性的。所以,不同的哈夫曼编码可能由相同的数据产生。

3).各节点相应的概率如下:

p(A)=0.16, p(B)=0.51, p(CE)=0.20, p(D)=0.13

D和A两个节点的概率最小。这两个节点作为叶子组合成一棵新的二叉树。根节点AD的组合概率为0.29。由AD到A的一边标记为1,由AD到D的一边标记为0。

如果不同的二叉树的根节点有相同的概率,那么具有从根到节点最短的最大路径的二叉树应先生成。这样能保持编码的长度基本稳定。

4).剩下节点的概率如下:

p(AD)=0.29, p(B)=0.51, p(CE)=0.20

AD和CE两节点的概率最小。它们生成一棵二叉树。其根节点ADCE的组合概率为0.49。由ADCE到AD一边标记为0,由ADCE到CE的一边标记为1。

5).剩下两个节点相应的概率如下:

p(ADCE)=0.49, p(B)=0.51

它们生成最后一棵根节点为ADCEB的二叉树。由ADCEB到B的一边记为1,由ADCEB到ADCE的一边记为0。

6).图03-02-2为霍夫曼编码。编码结果被存放在一个表中:

w(A)=001, w(B)=1, w(C)=011, w(D)=000, w(E)=010

图03-02-2 霍夫曼编码例

霍夫曼编码器的编码过程可用例子演示和解释。

下面是另一个霍夫曼编码例子。假定要编码的文本是:

"EXAMPLE OF HUFFMAN CODE"

首先,计算文本中符号出现的概率(表03-02-2)。

表03-02-2 符号在文本中出现的概率

符号

概率

E

2/25

X

1/25

A

2/25

M

2/25

P

1/25

L

1/25

O

2/25

F

2/25

H

1/25

U

1/25

C

1/25

D

1/25

I

1/25

N

2/25

G

1/25

空格

3/25

最后得到图03-02-3所示的编码树。

图03-02-3 霍夫曼编码树

在霍夫曼编码理论的基础上发展了一些改进的编码算法。其中一种称为自适应霍夫曼编码(Adaptive Huffman code)。这种方案......余下全文>>

问题五:哈夫曼编码码长怎么算

假设用于通信的电文由字符集{a,b,c,d,e,f,g,h}中的字母构成,这8个字母在电文中出现的概率分别为{0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.10}. (1)为这8个字母设计哈夫曼编码。 (2)若用这三位二进制数(0…7)对这8个字母进行等长编码,则哈夫曼编码的平均码长是等长编码的百分之几?它使电文总长平均压缩多少? 解: (1)哈夫曼编码 根据上图可得编码表: a:1001 b:01 c:10111 d:1010 e:11 f:10110 g:00 h:1000 (2)用三位二进行数进行的等长编码平均长度为3,而根据哈夫曼树编码的平均码长为: 4*0.07+2*0.19+5*0.02+4*0.06+2*0.32+5*0.03+2*0.21+4*0.10=2.61 2.61/3=0.87=87% 其平均码长是等长码的87%。 所以平均压缩率为13%。 记得刚学哈夫曼树的时候还做过一道简单的题,好象是关于分数统计输入的,找不到题目了. 参考资料: 51zk.csai.cn/sjjg/200609041055411573.htm

求采纳

问题六:哈夫曼编码算法

因为其中一个不能是另一个的前缀 所以只能是1111、1110、1101、1100

问题七:哈夫曼编码的程序实现

#include #include #include #include #define M 100typedef struct Fano_Node{char ch;float weight;}FanoNode[M];typedef struct node{int start;int end;struct node *next;}LinkQueueNode;typedef struct{LinkQueueNode *front;LinkQueueNode *rear;}LinkQueue;//建立队列void EnterQueue(LinkQueue *q,int s,int e){LinkQueueNode *NewNode;//生成新节点NewNode=(LinkQueueNode*)malloc(sizeof( LinkQueueNode ));if(NewNode!=NULL){NewNode->start=s;NewNode->end=e;NewNode->next=NULL;q->rear->next=NewNode;q->rear=NewNode;}else{printf(Error!);exit(-1);}}//按权分组void Divide(FanoNode f,int s,int *m,int e){int i;float sum,sum1;sum=0;for(i=s;i<=e;i++)sum+=f[i].weight;//*m=s;sum1=0;for(i=s;ifabs(sum-2*sum1-2*f[i+1].weight)?(i+1):*m;if(*m==i) break;}}void main(){int i,j,n,max,m,h[M];int sta,end;float w;char c,fc[M][M];FanoNode FN;LinkQueueNode *p;LinkQueue *Q;//初始化队QQ=(LinkQueue *)malloc(sizeof(LinkQueue));Q->front=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));Q->rear=Q->front;Q->front->next=NULL;printf(\t***FanoCoding***\n);printf(Please input the number of node:);//输入信息scanf(%d,&n);//超过定义M,退出if(n>=M){printf(>=%d,M);exit(-1);}i=1; //从第二个元素开始录入while(i<=n){printf(%d weight and node:,i);scanf(%f %c,&FN[i].weight,&FN[i].ch);for(j=1;j>

问题八:哈夫曼编码 C源代码 25分

#include

#define MAXBIT 10 /*定义哈夫曼编码的最大长度*/

#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;

}Hnodetype;

void huffmantree(Hnodetype huffnode[MAXNODE],int n) /*构造哈夫曼树的函数*/

{

int i,j,m1,m2,x1,x2;

for(i=0;i<2*n-1;i++) /*存放哈夫曼树结点的数组huffnode[]初始化*/

{

huffnode[i].weight=0;

huffnode[i].parent=-1;

huffnode[i].lchild=-1;

huffnode[i].rchild=-1;

}

for(i=0;i

{

printf("please input %d character's weight\n",i);

scanf("%d",&huffnode[i].weight);

}

for(i=0;i

{

m1=m2=MAXVALUE;

x1=x2=0;

for(j=0;j

{

if(huffnode[j].weight

{

m2=m1;x2=x1;m1=huffnode[j].weight;x1=j;

}

else if(huffnode[j].weight

{

m2=huffnode[j].weight;x2=j;

}

}

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矗

}

}

void main()

{

Hnodetype huffnode[MAXNODE];

Hcodetype huffcode[MAXLEAF],cd;

int i,j,c,p,n;

printf("please input n\n");

scanf("%d",&n); /*输入叶子节点个数*/

huff......余下全文>>

字典词典长度一定的铁丝长度一定的铁丝【范文精选】长度一定的铁丝【专家解析】家园共育小知识家园共育小知识【范文精选】家园共育小知识【专家解析】古代九州之首古代九州之首【范文精选】古代九州之首【专家解析】