哈夫曼树

所以我们的结点要设置一下

typedef struct huffNode
{
	unsigned int weight;   //权重
	unsigned int lchild, rchild, parent;  //左右子节点和父节点
}HTNode, *HuffTree;

int w[N] = { 0, 1, 2, 4, 5, 6 }; //第0个元素保留不用，只存1，2，4，5，6

所以下面的数组也是从i=1开始遍历

已经初始化完成，我们需要找到最小的两个值，我们要找的是没有入树的结点，也就是parent = 0的结点

//找出数组中权值最小的两个节点下标,分别用s1和s2保存
void select(const HuffTree &HT, int n, int &s1, int &s2)
{
	int i;
	s1 = s2 = 0;
	int min1 = INT_MAX;//最小值，INT_MAX在<limits.h>中定义的
	int min2 = INT_MAX;//次小值

	for (i = 1; i <= n; ++i)
	{
		if (HT[i].parent == 0)
		{//筛选没有父节点的最小和次小权值下标
			if (HT[i].weight < min1)
			{//如果比最小值小
				min2 = min1;  // 次小变为原来最小
				s2 = s1;  
				min1 = HT[i].weight;  // 更新最小值
				s1 = i;
			}
			else if ((HT[i].weight >= min1) && (HT[i].weight < min2))
			{//如果大于等于最小值，且小于次小值
				min2 = HT[i].weight;  // 更新次小值
				s2 = i;
			}
			else
			{//如果大于次小值，则什么都不做
				;
			}
		}
	}
}

接下来我们需要构建哈夫曼树

最后哈夫曼编码

代码

//huffmanCoding.c
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#define N 6
/*
构造赫夫曼树
n个叶子  2n+1个结点
一组带权值的叶子
找权值最小的两个叶子  （ 寻找最小两个权值的叶子
生成新结点
其权值为两叶子权值之和
两叶子的父节点改为新生成结点
新生成结点 父节点为 0 。 左右孩子结点是两叶子 （规定权值小的在左  大的在右

生成赫夫曼编码
二维数组
for循环
从叶子到根 。n-1 = '\0'  start  = n - 1  start--
n - 1 组二进制编码 长度为 n-start
*/
typedef struct huffNode
{
	unsigned int weight;   //权重
	unsigned int lchild, rchild, parent;  //左右子节点和父节点
}HTNode, *HuffTree;
typedef char **HuffCode;

//找出数组中无父节点且权值最小的两个节点下标,分别用s1和s2保存
void select(const HuffTree &HT, int n, int &s1, int &s2);
//HT:哈夫曼树，HC:哈夫曼编码，w:构造哈夫曼树节点的权值，n:构造哈夫曼树节点的个数
void HuffmanCode(HuffTree &HT, HuffCode &HC, int *w, int n);


int main()
{
	int i;
	char key[N] = { '0', 'A', 'B', 'C', 'D', 'E' };//第0个元素保留不用
	int w[N] = { 0, 1, 2, 4, 5, 6 }; //第0个元素保留不用，只存1，2，4，5，6
	HuffTree HT;
	HuffCode HC;
	HuffmanCode(HT, HC, w, N - 1);
	for (i = 1; i < N; i++)
		printf("%c:%s\n", key[i], HC[i]);

	printf("\n");
	system("pause");
	return 0;
}




//找出数组中权值最小的两个节点下标,分别用s1和s2保存
void select(const HuffTree &HT, int n, int &s1, int &s2)
{
	int i;
	s1 = s2 = 0;
	int min1 = INT_MAX;//最小值，INT_MAX在<limits.h>中定义的
	int min2 = INT_MAX;//次小值

	for (i = 1; i <= n; ++i)
	{
		if (HT[i].parent == 0)
		{//筛选没有父节点的最小和次小权值下标
			if (HT[i].weight < min1)
			{//如果比最小值小
				min2 = min1;  // 次小变为原来最小
				s2 = s1;  
				min1 = HT[i].weight;  // 更新最小值
				s1 = i;
			}
			else if ((HT[i].weight >= min1) && (HT[i].weight < min2))
			{//如果大于等于最小值，且小于次小值
				min2 = HT[i].weight;  // 更新次小值
				s2 = i;
			}
			else
			{//如果大于次小值，则什么都不做
				;
			}
		}
	}
}

//HT:哈夫曼树，HC:哈夫曼编码，w:构造哈夫曼树节点的权值，n:构造哈夫曼树节点的个数
void HuffmanCode(HuffTree &HT, HuffCode &HC, int *w, int n)
{
	int s1;
	int s2;
	int m = 2 * n - 1;       //容易知道n个节点构造的哈夫曼树是2n-1个节点
	int i, c, f, start;
	char *code;  //暂存编码的
	HT = (HuffTree)malloc((m + 1)*sizeof(HTNode));  //0单元未使用,从1开始存储


	for (i = 1; i <= n; i++)
		HT[i] = { w[i], 0, 0, 0 };//初始化前n个节点(构造哈夫曼树的原始节点)

	for (i = n + 1; i <= m; i++)
		HT[i] = { 0, 0, 0, 0 };  //初始化后n-1个节点

	//构建哈夫曼树
	for (i = n + 1; i <= m; i++)
	{
		select(HT, i - 1, s1, s2);//找出前i-1个节点中权值最小的节点下标，
		HT[s1].parent = i;
		HT[s2].parent = i;
		HT[i].lchild = s1;
		HT[i].rchild = s2;
		HT[i].weight = HT[s1].weight + HT[s2].weight;
	}
	//哈夫曼编码
	HC = (char **)malloc((n)*sizeof(char *));
	//暂存编码
	code = (char *)malloc(n*sizeof(char));//使用了第0单元
	code[n - 1] = '\0';
	for (i = 1; i <= n; i++)  // 要生成n个哈夫曼编码，一个个生成
	{
		start = n - 1;  // 从最后一个结点开始填充的，倒着填,现在指向‘\0’
		c = i;  // c的作用在于记录自己的序号与父节点的左右孩子对比，看自己是左孩子还是右孩子
		f = HT[i].parent;
		while (f != 0){  // 从叶子结点开始向上回溯，直到根节点，因为根节点的parent = 0
			--start;
			if (HT[f].lchild == c) code[start] = '0';
			else				   code[start] = '1';
			c = f;  // 因为要回溯，所以现在f是下一轮比较的序号
			f = HT[f].parent;  // 继续向上回溯
		}
		HC[i] = new char[n - start];  // 为第i个字符串编码分配空间
		strcpy(HC[i], &code[start]);  // 将求得的编码从临时空间code复制到HC的当前行中
	}
	delete code;  // 释放临时空间
}