数据结构与算法之赫夫曼树

赫夫曼树的概念

赫夫曼树：又称最优树，是一类带权路径长度最短的树，有着广泛的应用
1.最优二叉树（赫夫曼树）
首先给出路径和路径长度的概念，从树中的一个结点到另一个结点之间的分支构成这两个结点之间的路径，路径上的分支数目称作路经长度。树的路径长度是从树根到每一结点的路径长度之和。完全二叉树路径长度最短的二叉树。

赫夫曼树的建立：
不断地取最小的两个节点，构建成一棵树，然后将刚构建的树加入到数组中，不断的构建，最终构建出一棵树。
存储方式：静态存储

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<stack>
#include <queue>
//静态存储
using namespace std;
const int n = 8; //leaf叶子的个数
const int m = n * 2; //node 节点个数
typedef unsigned int WeightType;
typedef unsigned int NodeType;
typedef struct
{
	WeightType weight;//权值
	NodeType parent, leftchild, rightchild;
}HTNode;

typedef HTNode HuffmanTree[m];

void PrintHuffmanTree(HuffmanTree hft)
{
	for (int i = 1; i < m; ++i)
	{
		printf("index %3d weight:%3d parent %3d Lchild %3d Rchild %3d\n",
			i, hft[i].weight, hft[i].parent, hft[i].leftchild, hft[i].rightchild);
	}
	printf("\n");
}
struct IndexWeigth
{
	int index;
	WeightType weight;
	operator WeightType()const { return weight; }
};
void CreateHuffmanTree(HuffmanTree hft)
{
	priority_queue<IndexWeigth,vector<IndexWeigth>,std::greater<IndexWeigth>>qu;//优先级队列，依次选择最小堆
	//每次取得第一小值
	for (int i = 1; i <= n; ++i)
	{
		qu.push(IndexWeigth{ i,hft[i].weight }); //将权值和下标放入队列
	}
	int k = n + 1;
	while (!qu.empty())
	{
		if (qu.empty())break;
		IndexWeigth left = qu.top(); qu.pop();
		if (qu.empty())break;
		IndexWeigth right = qu.top(); qu.pop();
		hft[k].weight = left.weight + right.weight;
		hft[k].leftchild = left.index;
		hft[k].rightchild = right.index;
		hft[left.index].parent = k;
		hft[right.index].parent = k;

		qu.push(IndexWeigth{ k,hft[k].weight });
		k += 1;
	}
}

void InitHuffmanTree(HuffmanTree hft, WeightType w[])
{
	memset(hft, 0, sizeof(HuffmanTree));
	for (int i = 0; i < n; ++i)
	{
		hft[i + 1].weight = w[i];
	}
}

int main()
{
	WeightType w[n] = { 5,29,7,8,14,23,3,11 };
	HuffmanTree hft = { 0 };
	InitHuffmanTree(hft, w);
	PrintHuffmanTree(hft);
	CreateHuffmanTree(hft);
	PrintHuffmanTree(hft);
	return 0;
}