/*
* 实现过程：着先通过 HuffmanTree() 函数构造哈夫曼树，然后在主函数 main()中
* 自底向上开始(也就是从数组序号为零的结点开始)向上层层判断，若在
* 父结点左侧，则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。
*------------------------------------------------------------------------*/
#include <stdio.h>
#include<stdlib.h>
#include<cstring>
const int MAXBIT = 100;
const int MAXVALUE = 10000;
const int MAXLEAF = 30;
const int MAXNODE = MAXLEAF*2 -1;
typedef struct
{
int bit[MAXBIT];
int start;
}HCodeType; // 编码结构体
typedef struct
{
int weight;
int parent;
int lchild;
int rchild;
int value;
}HNodeType; // 结点结构体
// 输入并初始化
void node_input(HNodeType HuffNode[], const int &n)
{
int i;
for(i=0; i<n; i++)
{
printf ("Please input weight of leaf node %d: \n", i);
scanf ("%d", &HuffNode[i].weight);//权值
HuffNode[i].parent =-1;
HuffNode[i].lchild =-1;
HuffNode[i].rchild =-1;// 初始值为-1
HuffNode[i].value=i; //现在用的是下标值，实际值，可根据情况替换为字母
}
}
void out_put(HCodeType HuffCode[], const int &n)
{
int i, j;
for (i=0; i<n; i++)
{
printf ("%d 's Huffman code is: ", i);
for (j=HuffCode[i].start+1; j < n; j++)
{
printf ("%d", HuffCode[i].bit[j]);
}
printf(" start:%d",HuffCode[i].start);
printf ("\n");
}
}
void min_two(HNodeType HuffNode[], const int &n,const int &i, int &x1, int &x2)
{
int j, m1, m2;
m1=m2=MAXVALUE; //m1、m2中存放两个无父结点且结点权值最小的两个结点
//找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树
for (j=0; j<n+i; j++)
{
if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
{
m2=m1;
x2=x1;
m1=HuffNode[j].weight;
x1=j;
}
else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
{
m2=HuffNode[j].weight;
x2=j;
}
}
}
// 构造一颗哈夫曼树
void HuffmanTree(HNodeType HuffNode[], const int &n)
{
//i： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，
//x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。
int i, x1, x2;
//循环构造 Huffman 树
for (i=0; i<n-1; i++)
{
x1=x2=0;
min_two(HuffNode, n, i, x1, x2);
/* 设置找到的两个子结点 x1、x2 的父结点信息 */
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;
HuffNode[n+i].parent = -1;// 新节点的父亲是-1
printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight); /* 用于测试 */
printf ("\n");
}
/*for(i=0;i<n+2;i++)
{
printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
}*///测试
} // end HuffmanTree
// 编码
void encodeing(HNodeType HuffNode[], HCodeType HuffCode[], const int &n)
{
int i, j, c, p;
HCodeType cd;
for (i=0; i < n; i++)
{
cd.start = n-1;
c = i;
p = HuffNode[c].parent;
while (p != -1) //父结点存在
{
if (HuffNode[p].lchild == c)
cd.bit[cd.start] = 0;
else
cd.bit[cd.start] = 1;
cd.start--; //求编码的低一位
c=p;
p=HuffNode[c].parent; // 设置下一循环条件
} // end while
// 保存求出的每个叶结点的哈夫曼编码和编码的起始位
for (j=cd.start+1; j<n; j++)
{
HuffCode[i].bit[j] = cd.bit[j];
}
HuffCode[i].start = cd.start;
}
}
//解码
void decodeing(char string[],HNodeType Buf[],int Num)
{
int i,tmp=0,code[1024];
int m=2*Num-1;
char *nump;
char num[1024];
for(i=0;i<strlen(string);i++)
{
if(string[i]=='0')
num[i]=0;
else if(string[i] == '1')
num[i]=1;
else
return;
}// 转化为数字
i=0;
nump=&num[0];
while(nump<(&num[strlen(string)]))
{
tmp=m-1;
while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
{
if(*nump==0)
{
tmp=Buf[tmp].lchild ;
}
else
tmp=Buf[tmp].rchild;
nump++;
}
printf("%d",Buf[tmp].value);
}
}
int main(void)
{
HNodeType HuffNode[MAXNODE]; //定义一个结点结构体数组
HCodeType HuffCode[MAXLEAF], cd; // 定义一个编码结构体数组， 同时定义一个临时变量来存放求解编码时的信息
int i, j, n;
char pp[100];
printf ("Please input n:\n");
scanf ("%d", &n);
// 输入n个节点
node_input(HuffNode, n);
// 构造哈夫曼树
HuffmanTree(HuffNode, n);
//编码
encodeing(HuffNode,HuffCode,n);
// 输出已保存好的所有存在编码的哈夫曼编码
out_put(HuffCode,n);
// 解码过程
printf("Decoding?Please Enter code:\n");
scanf("%s",&pp);
decodeing(pp,HuffNode,n);
return 0;
}原文地址：http://blog.csdn.net/u010700335/article/details/39557347
