在电报通讯中,电文是以二进制的0、1序列传送的。字符集中的字符的使用频率是不同的(比如e和t的使用较之q和z要频繁得多),哈夫曼编码可以使得编码的总长最短,从而相同的位长可以传送更多的信息。
本程序以下面的字符及使用频率为例:
字符 | 权值 |
a | 0.12 |
b | 0.40 |
c | 0.15 |
d | 0.08 |
e | 0.25 |
首先建立哈夫曼树:
i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
tree[i].ch | a | b | c | d | e |
|
|
|
|
tree[i].weight | 0.12 | 0.40 | 0.15 | 0.08 | 0.25 | 0.20 | 0.35 | 0.60 | 1.00 |
tree[i].parent | 5 | 8 | 6 | 5 | 7 | 6 | 7 | 8 | 0 |
tree[i].lchild | -1 | -1 | -1 | -1 | -1 | 3 | 2 | 4 | 1 |
tree[i].rchild | -1 | -1 | -1 | -1 | -1 | 0 | 5 | 6 | 7 |
得到哈夫曼树和哈夫曼编码如下:
下面是哈夫曼编码的存储结构:
序号 | bits | ch | start | |||
0 | 1 | 1 | 1 | 1 | a | 2 |
1 |
|
|
| 0 | b | 5 |
2 |
| 1 | 1 | 0 | c | 3 |
3 | 1 | 1 | 1 | 0 | d | 2 |
4 |
|
| 1 | 0 | e | 4 |
程序清单如下:
#include<stdio.h>
#define n 5 //叶子数目
#define m (2*n-1) //结点总数
#define maxval 10000.0
#define maxsize 100 //哈夫曼编码的最大位数
typedef struct
{
char ch;
float weight;
int lchild,rchild,parent;
}hufmtree;
typedef struct
{
char bits[n]; //位串
int start; //编码在位串中的起始位置
char ch; //字符
}codetype;
void huffman(hufmtree tree[]);//建立哈夫曼树
void huffmancode(codetype code[],hufmtree tree[]);//根据哈夫曼树求出哈夫曼编码
void decode(hufmtree tree[]);//依次读入电文,根据哈夫曼树译码
void main()
{
printf(" ——哈夫曼编码——\n");
printf("总共有%d个字符\n",n);
hufmtree tree[m];
codetype code[n];
int i,j;//循环变量
huffman(tree);//建立哈夫曼树
huffmancode(code,tree);//根据哈夫曼树求出哈夫曼编码
printf("【输出每个字符的哈夫曼编码】\n");
for(i=0;i<n;i++)
{
printf("%c: ",code[i].ch);
for(j=code[i].start;j<n;j++)
printf("%c ",code[i].bits[j]);
printf("\n");
}
printf("【读入电文,并进行译码】\n");
decode(tree);//依次读入电文,根据哈夫曼树译码
}
void huffman(hufmtree tree[])//建立哈夫曼树
{
int i,j,p1,p2;//p1,p2分别记住每次合并时权值最小和次小的两个根结点的下标
float small1,small2,f;
char c;
for(i=0;i<m;i++) //初始化
{
tree[i].parent=0;
tree[i].lchild=-1;
tree[i].rchild=-1;
tree[i].weight=0.0;
}
printf("【依次读入前%d个结点的字符及权值(中间用空格隔开)】\n",n);
for(i=0;i<n;i++) //读入前n个结点的字符及权值
{
printf("输入第%d个字符为和权值",i+1);
scanf("%c %f",&c,&f);
getchar();
tree[i].ch=c;
tree[i].weight=f;
}
for(i=n;i<m;i++) //进行n-1次合并,产生n-1个新结点
{
p1=0;p2=0;
small1=maxval;small2=maxval; //maxval是float类型的最大值
for(j=0;j<i;j++) //选出两个权值最小的根结点
if(tree[j].parent==0)
if(tree[j].weight<small1)
{
small2=small1; //改变最小权、次小权及对应的位置
small1=tree[j].weight;
p2=p1;
p1=j;
}
else
if(tree[j].weight<small2)
{
small2=tree[j].weight; //改变次小权及位置
p2=j;
}
tree[p1].parent=i;
tree[p2].parent=i;
tree[i].lchild=p1; //最小权根结点是新结点的左孩子
tree[i].rchild=p2; //次小权根结点是新结点的右孩子
tree[i].weight=tree[p1].weight+tree[p2].weight;
}
}//huffman
void huffmancode(codetype code[],hufmtree tree[])//根据哈夫曼树求出哈夫曼编码
//codetype code[]为求出的哈夫曼编码
//hufmtree tree[]为已知的哈夫曼树
{
int i,c,p;
codetype cd; //缓冲变量
for(i=0;i<n;i++)
{
cd.start=n;
cd.ch=tree[i].ch;
c=i; //从叶结点出发向上回溯
p=tree[i].parent; //tree[p]是tree[i]的双亲
while(p!=0)
{
cd.start--;
if(tree[p].lchild==c)
cd.bits[cd.start]='0'; //tree[i]是左子树,生成代码'0'
else
cd.bits[cd.start]='1'; //tree[i]是右子树,生成代码'1'
c=p;
p=tree[p].parent;
}
code[i]=cd; //第i+1个字符的编码存入code[i]
}
}//huffmancode
void decode(hufmtree tree[])//依次读入电文,根据哈夫曼树译码
{
int i,j=0;
char b[maxsize];
char endflag='2'; //电文结束标志取2
i=m-1; //从根结点开始往下搜索
printf("输入发送的编码(以'2'为结束标志):");
gets(b);
printf("译码后的字符为");
while(b[j]!='2')
{
if(b[j]=='0')
i=tree[i].lchild; //走向左孩子
else
i=tree[i].rchild; //走向右孩子
if(tree[i].lchild==-1) //tree[i]是叶结点
{
printf("%c",tree[i].ch);
i=m-1; //回到根结点
}
j++;
}
printf("\n");
if(tree[i].lchild!=-1&&b[j]!='2') //电文读完,但尚未到叶子结点
printf("\nERROR\n"); //输入电文有错
}//decode
贴出一例运行结果:
另一组实例实现编码
head.h
#ifndef _HEAD_H_
#define _HEAD_H_
/**************************HUFFMAN*********************/
typedef struct btree
{
//记录权值
int w;
//记录字符
char c;
//记录编码
char code[20];
//左孩子
struct btree *lchild;
//右孩子
struct btree *rchild;
}HUFFMAN;
/***********************************************************/
typedef HUFFMAN * DATATYPE;
//节点的类型
struct node
{
DATATYPE data;
struct node *next;
};
/****************************栈*************************/
//栈头的类型
typedef struct
{
//栈顶元素的位置
struct node *top;
//栈中元素的个数
int n;
}LinkStack;
extern LinkStack *create_empty_stack();
extern int is_empty_stack(LinkStack *s);
extern int push_stack(LinkStack *s,DATATYPE data);
extern DATATYPE pop_stack(LinkStack *s);
extern DATATYPE get_top_data(LinkStack *s);
/**************************队列***********************/
typedef struct
{
struct node *front;
struct node *rear;
}LinkQueue;
extern LinkQueue *create_empty_queue();
extern int is_empty_queue(LinkQueue *q);
extern int EnterQueue(LinkQueue *q,DATATYPE data);
extern DATATYPE DeleteQueue(LinkQueue *q);
#endif
huffman.c
#include <stdio.h>
#include <stdlib.h>
#include "head.h"
#include <string.h>
#define N 4
//A:0 B:1 C:2 D:3
enum{A,B,C,D};
//enum{A = 3,B,C,D}; A = 3,B = 4, C=5 ,D=6
int count_freq(char *s,int freq[])
{
int i = 0;
while(s[i])
{
switch(s[i])
{
case 'A':
freq[A] ++;
break;
case 'B':
freq[B] ++;
break;
case 'C':
freq[C] ++;
break;
case 'D':
freq[D]++;
break;
}
i ++;
}
return 0;
}
int insert_order_queue(LinkQueue *q,DATATYPE data)
{
struct node *temp;
struct node *p = q->front;
while(p->next != NULL &&\
p->next->data->w < data->w)
{
p = p->next;
}
temp = (struct node *)malloc(sizeof(struct node));
temp->data = data;
temp->next = p->next;
p->next = temp;
//更新rear
p = q->front;
while(p->next != NULL) p = p->next;
q->rear = p;
return 0;
}
HUFFMAN *space_hffman_node(int w,char c)
{
HUFFMAN *tree;
tree = (HUFFMAN *)malloc(sizeof(HUFFMAN));
memset(tree,0,sizeof(HUFFMAN));
tree->w = w;
tree->c = c;
tree->lchild = tree->rchild = NULL;
return tree;
}
LinkQueue *create_huffman_queue(int freq[])
{
int i = 0;
HUFFMAN *temp;
LinkQueue *q = create_empty_queue();
for(i = 0;i < N; i ++)
{
switch(i)
{
case A:
temp = space_hffman_node(freq[A],'A');
break;
case B:
temp = space_hffman_node(freq[B],'B');
break;
case C:
temp = space_hffman_node(freq[C],'C');
break;
case D:
temp = space_hffman_node(freq[D],'D');
break;
}
insert_order_queue(q,temp);
}
return q;
}
int is_onenode_queue(LinkQueue *q)
{
return q->front->next == q->rear ? 1 : 0;
}
HUFFMAN *create_huffman_tree(LinkQueue *q)
{
HUFFMAN *ltree,*rtree,*tree;
while(!is_onenode_queue(q))
{
ltree = DeleteQueue(q);
rtree = DeleteQueue(q);
tree = space_hffman_node(ltree->w + rtree->w,'\0');
tree->lchild = ltree;
tree->rchild = rtree;
insert_order_queue(q,tree);
}
return DeleteQueue(q);
}
char *code_addr[N];
int NoOrder(HUFFMAN *root)
{
HUFFMAN *temp;
LinkQueue *q = create_empty_queue();
EnterQueue(q,root);
while(!is_empty_queue(q))
{
temp = DeleteQueue(q);
// printf("%d ",temp->w);
if(temp->lchild == NULL && temp->rchild == NULL)
{
switch(temp->c)
{
case 'A':
printf("A:%s.\n",temp->code);
code_addr[A] = temp->code;
break;
case 'B':
printf("B:%s.\n",temp->code);
code_addr[B] = temp->code;
break;
case 'C':
printf("C:%s.\n",temp->code);
code_addr[C] = temp->code;
break;
case 'D':
printf("D:%s.\n",temp->code);
code_addr[D] = temp->code;
break;
}
}
if(temp->lchild != NULL)
{
strcpy(temp->lchild->code,temp->code);
strcat(temp->lchild->code,"0");
EnterQueue(q,temp->lchild);
}
if(temp->rchild != NULL)
{
strcpy(temp->rchild->code,temp->code);
strcat(temp->rchild->code,"1");
EnterQueue(q,temp->rchild);
}
}
printf("\n");
return 0;
}
int compress(char *pbuf,char *s)
{
while(*s)
{
switch(*s)
{
case 'A':
strcat(pbuf,code_addr[A]);
break;
case 'B':
strcat(pbuf,code_addr[B]);
break;
case 'C':
strcat(pbuf,code_addr[C]);
break;
case 'D':
strcat(pbuf,code_addr[D]);
break;
}
s++;
}
return 0;
}
//A,B,C,D
int main(int argc, const char *argv[])
{
LinkQueue *q;
HUFFMAN *root;
int freq[N] = {0};
char string[1024];
char compress_buf[1024] = {0};
printf("Input string:");
scanf("%s",string);
count_freq(string,freq);
q = create_huffman_queue(freq);
root = create_huffman_tree(q);
NoOrder(root);
compress(compress_buf,string);
printf("compress_buf : %s.\n",compress_buf);
return 0;
}
linkqueue.c
#include <stdio.h>
#include <stdlib.h>
#include "head.h"
LinkQueue *create_empty_queue()
{
struct node *head;
LinkQueue *q;
head = (struct node *)malloc(sizeof(struct node));
head->next = NULL;
q = (LinkQueue *)malloc(sizeof(LinkQueue));
q->front = q->rear = head;
return q;
}
int is_empty_queue(LinkQueue *q)
{
return q->front == q->rear ? 1 : 0;
}
int EnterQueue(LinkQueue *q,DATATYPE data)
{
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
temp->data = data;
temp->next = NULL;
q->rear->next = temp;
q->rear = temp;
return 0;
}
DATATYPE DeleteQueue(LinkQueue *q)
{
struct node *temp;
temp = q->front;
q->front = temp->next;
free(temp);
return q->front->data;
}