哈夫曼树创建_以及_构造哈夫曼编码

通过 最小堆，来构建 哈夫曼树，再通过 遍历，借一个数组 来保存 路径 上的 编码。

#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);			//  遍历

}