通过 最小堆,来构建 哈夫曼树,再通过 遍历,借一个数组 来保存 路径 上的 编码。
#include<iostream>
using namespace std;
// 哈夫曼树节点
typedef struct huff{
int data;
struct huff * left;
struct huff * right;
}*huffman;
// 最小堆
typedef struct zui_xiao_dui{
huffman elements[10];
int num;
}*min_heap;
// 创建 最小堆
min_heap Create(int num){
min_heap H=new struct zui_xiao_dui;
// H->elements=new huffman[num+1]; // 从 下标为 1 的地方开始存放
H->num=0;
// 这里 由于 H->elements[0]中的元素 指向的地方未初始化
// 所以切记 不可以 直接 H->elements[0]->data=-10;
huffman temp=new struct huff;
H->elements[0]=temp;
H->elements[0]->data=-10; // 定义哨兵 , 这里放一个很小的数
return H;
}
// 将 H中以 H->Data[p]为根的子堆调整为最大堆
void PercDown( min_heap H, int p ){
int Parent, Child;
int X;
X = H->elements[p]->data;
huffman temp=H->elements[p]; // 这里 注意 保存
for( Parent=p; Parent*2<=H->num; Parent=Child ) {
Child = Parent * 2;
if( (Child!=H->num) && (H->elements[Child]->data>H->elements[Child+1]->data) )
Child++; /* Child指向左右子结点的较小者 */
if( X <= H->elements[Child]->data )
break; // 找到了合适位置
else
H->elements[Parent] = H->elements[Child]; // 将那个较大值调上来, 之后在下一层继续找
}
H->elements[Parent] = temp;
}
void BuildHeap( min_heap H ){
int i;
for( i = H->num/2; i>0; i-- )
PercDown( H, i );
}
// 取出 最小堆 的最小节点
huffman DeleteMin(min_heap H){
int parent,child;
huffman MinItem,temp;
MinItem=H->elements[1]; // 取出最小元素
temp=H->elements[H->num--]; // 指向 最后一个元素
//寻找 temp 应该放置的地方: parent, 先放在 根节点, 然后 逐层的 寻找 合适的位置
for(parent=1;parent*2<=H->num;parent=child){
child=parent*2;
if((child!=H->num)&&(H->elements[child]->data>H->elements[child+1]->data))
child++; // 找出 左右儿子 中 较小的一个
if(temp->data<=H->elements[child]->data) // 如果 temp 比 这个位置的左右儿子 都大, 那 temp 放在这里就是合适的
break;
else
H->elements[parent]=H->elements[child];
}
H->elements[parent]=temp;
return MinItem;
}
// 向 堆中 插入元素
void Insert(min_heap H,huffman item){
// H->Elements[0] 已被 设置为 哨兵
int i;
i=++H->num;
for(;H->elements[i/2]->data>item->data;i/=2){ // 将 比 item 大的 父节点元素 向下移
H->elements[i]=H->elements[i/2];
}
H->elements[i]=item; // 找到要插入的位置
}
// 建立 哈夫曼 树
huffman huffman_build(min_heap H){
huffman T;
BuildHeap(H); // 调整为最小堆 O(n) 复杂度
int count=H->num;
for(int i=1;i<count;i++){ // Size-1 次 合并
T=new struct huff;
T->left=DeleteMin(H); // 从堆中 取出两个 最小的
T->left->data;
T->right=DeleteMin(H);
T->right->data;
T->data=T->left->data+T->right->data;
Insert(H,T); // 构建形成的新的节点插入到堆里
}
T=DeleteMin(H);
return T;
}
// len 是 路径长
// bian_ma 数组里放的是 编码
void Mid_order(huffman L, int (&bian_ma)[10],int &len){
if(L){
if(L->left==NULL&&L->right==NULL){
cout<<L->data<<ends;
for(int j=0;j<len;j++){
cout<<bian_ma[j];
}
cout<<'\n';
len--;
return;
}
bian_ma[len++]=0;
Mid_order(L->left,bian_ma,len);
bian_ma[len++]=1;
Mid_order(L->right,bian_ma,len);
len-=1;
}
}
int main(){
int num;
cin>>num; // 元素个数
min_heap P=Create(num); // 建 堆
for(int i=1;i<num+1;i++){
huffman jie_dian =new struct huff;
cin>>jie_dian->data;
jie_dian->left=jie_dian->right=NULL;
P->elements[i]=jie_dian;
P->num++;
}
huffman L=huffman_build(P); // 建 哈夫曼树
static int bian_ma[10]={0};
static int len=0;
Mid_order(L,bian_ma,len); // 遍历
}