C语言实现哈夫曼编码与译码

在电报通讯中,电文是以二进制的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

 

贴出一例运行结果:

参考C语言哈夫曼编码与解码

 另一组实例实现编码

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

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页
实付 79.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值