二叉树的贪心策略---哈夫曼编码

概述:

1.通常的编码方法有固定长度和不等长度编码两种

2.最优编码方案的目的是使总码长度最短。利用字符的使用频率来编码，是不等长编码方法，使得经常使用的字符编码较短，不常使用的字符编码较长。

如果采用等长的编码方案，假设所有字符的编码都等长，则表示n个不同的字符需要位。如果每个字符的使用频率相等的话，固定长度编码是空间效率最高的方法。

tipes:等长编码需要的二进制位是|logN|取上限.

关键问题:

1.包含两个关键问题

(1)编码尽可能的短

使用频率高的字符编码较短，使用频率低的编码较长，可提高压缩率，节省空间，也能提高运算和通信速度。即频率越高，编码越短。

(2)不能有二义性

解决的办法是：任何一个字符的编码不能是另一个字符编码的前缀，即前缀码特性。

哈弗曼编码的基本思想:

哈夫曼编码的基本思想是以字符的使用频率作为权构建一棵哈夫曼树，然后利用哈夫曼树对字符进行编码。

构造哈夫曼树的方法:

是将所要编码的字符作为叶子结点，该字符在文件中的使用频率作为叶子结点的权值，以自底向上的方式，通过n-1次的“合并”运算后构造出的树。核心思想是让权值大的叶子离根最近。

哈夫曼树的贪心策略:

贪心策略是每次从树的集合中取出没有双亲且权值最小的两棵树作为左右子树，构造一棵新树，新树根节点的权值为其左右孩子结点权值之和，将新树插入到树的集合中。

确定合适的数据结构与构造哈夫曼树

1.哈夫曼树中没有度为1的节点,所以有一颗节点数为n的哈夫曼树一共有2n-1个节点(每次合并都会多一个新节点)

2.当构造好了哈夫曼树则需要根据哈夫曼树进行编码,因为每个叶子节点的双亲结点唯一,所以可以走从叶子到根的路径

3.译码需要从根到叶子的路径,对于每个节点而言,需要知道每个节点的权值,双亲,左右孩子和节点的信息

typedef struct
{
	double weight;
	int parent;
	int lchild;
	int rchild;
	char value;
}HNodeType;

 我们将每个节点的信息存放到数组中进而可以从一维数组拓展到二维数组,刚才说了有n个码,构成二叉树会有2n-1个节点,这里有6个码,所以会有11个节点.

parent,lchild,rchild 都是记录节点的下标,因为数组没有-1下标,所以初始化为-1,代表没有父节点

构造二叉树的过程就是填表的过程

每次寻找已存在的最小的没有父节点的两个节点,权值加起来放入第N+i的位置,并且填好父节点与子节点的值,如此反复,直到表填满为止

 

void HuffmanTree(HNodeType HuffNode[maxnode], int n)
{
	int x1, x2;  //x1,x2代表的是最小权值节点的下标  x1最小,x2次小
	double m1, m2; //m1,m2为最小权值,m1最小m2次小

	//初始化哈夫曼树组中的节点
	for (int i = 0; i < 2 * n - 1; i++)
	{
		HuffNode[i].weight = 0;
		HuffNode[i].parent = -1;
		HuffNode[i].lchild = -1;
		HuffNode[i].rchild = -1;
	}

	//输入每个叶子的权值
	for (int i = 0; i < n; i++)
	{
		cout << "请输入第" << i + 1 << "个叶子的值与权值" << endl;
		cin >> HuffNode[i].value >> HuffNode[i].weight;
	}

	//构造哈夫曼树
	for (int i = 0; i < n - 1; i++)  //n个节点需要构造n-1次
	{
		m1 = m2 = maxvalue;//存放无父节点且权值最小的节点
		x1 = x2 = 0;
		for (int j = 0; j < n + i; j++)
		{
			if (HuffNode[j].weight < m1 && HuffNode[j].parent == -1)
			{
                //如果成立 m1就不是最小的了而是次小,所以将最小权值节点赋值给m1
                //m2接收之前m1的最小值
				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;
			}
		}
               //新节点的信息填入
		HuffNode[x1].parent = n + i;
		HuffNode[x2].parent = n + i;
		HuffNode[n + i].weight = m1 + m2;
		HuffNode[n + i].lchild = x1;
		HuffNode[n + i].rchild = x2;
		cout << "x1.weight and x2.weight in round " << i + 1 << "\t" << HuffNode[x1].weight << "\t" << HuffNode[x2].weight << endl;
	}

}

哈弗曼编码

1.有几个需要编码的信息,就需要多少个存储空间存储编码

例如有6个字符需要编码,则需要一个一位数组存放其中一个字符的编码,共6个,再用一维数组存放这六个编码形成的二位数组就行了

2.为了方便后序的译码是从前向后读取,所以编码的存储是从后向前

 

//编码结构体
typedef struct
{
	int bit[maxbit];
	int start;
}HCodeType;

 3.用c 记录子节点,p记录父节点,判断c是p的左孩子还是右孩子,左孩子的话说明第一个编码时0反之为1

3.

 完整代码:

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
using namespace std;

const int maxbit = 100;   //最大编码长度
const int maxvalue = 10000; //最大权值
const int maxleaf = 30;  //最多的叶子数
const int maxnode = maxleaf * 2 - 1;   //节点数为2n-1

//节点结构体
typedef struct
{
	double weight;
	int parent;
	int lchild;
	int rchild;
	char value;
}HNodeType;

//编码结构体
typedef struct
{
	int bit[maxbit];
	int start;
}HCodeType;

HNodeType HuffNode[maxnode];  //节点结构体数组
HCodeType HuffCode[maxleaf];  //编码结构体数组

//构造哈夫曼树
void HuffmanTree(HNodeType HuffNode[maxnode], int n)
{
	int x1, x2;
	double m1, m2;

	//初始化哈夫曼树组中的节点
	for (int i = 0; i < 2 * n - 1; i++)
	{
		HuffNode[i].weight = 0;
		HuffNode[i].parent = -1;
		HuffNode[i].lchild = -1;
		HuffNode[i].rchild = -1;
	}

	//输入每个叶子的权值
	for (int i = 0; i < n; i++)
	{
		cout << "请输入第" << i + 1 << "个叶子的值与权值" << endl;
		cin >> HuffNode[i].value >> HuffNode[i].weight;
	}

	//构造哈夫曼树
	for (int i = 0; i < n - 1; i++) //合并n-1次
	{
		m1 = m2 = maxvalue;//存放无父节点且权值最小的节点
		x1 = x2 = 0;
		for (int 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;
			}
		}

		HuffNode[x1].parent = n + i;
		HuffNode[x2].parent = n + i;
		HuffNode[n + i].weight = m1 + m2;
		HuffNode[n + i].lchild = x1;
		HuffNode[n + i].rchild = x2;
		cout << "x1.weight and x2.weight in round " << i + 1 << "\t" << HuffNode[x1].weight << "\t" << HuffNode[x2].weight << endl;
	}

}

void HuffmanCode(HCodeType HuffCode[maxleaf], int n)
{
	HCodeType cd; //临时变量存放求编码时的信息
	for (int i = 0; i < n; i++)
	{
		cd.start = n - 1;
		int c = i;
		int 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;
			
		}
		
		for (int j = cd.start + 1; j < n; j++)
		{
			HuffCode[i].bit[j] = cd.bit[j];
		}
		HuffCode[i].start = cd.start;
	}
}

int main()
{

	int i, j, n;
	cout << "请输入有几个元素" << endl;
	cin >> n;
	HuffmanTree(HuffNode, n);
	HuffmanCode(HuffCode, n);

	for (i = 0; i < n; i++)
	{
		cout << HuffNode[i].value << "编码:";
		for (j = HuffCode[i].start + 1; j < n; j++)
		{
			cout << HuffCode[i].bit[j];
		}
		cout << endl;
	}
	

	system("pause");
	return EXIT_SUCCESS;
}