堆与优先队列、哈夫曼树（贪心算法）

　　一、哈夫曼树，最优二叉树，WPL最小的二叉树 

　　带权路径长度(WPL)：

　　设二叉树有n个叶子结点，每个叶子结点带 有权值 w_k，从根结点到每个叶子结点的长度为 l_k，则每个叶子结点的带权路径长度之和WPL

　　哈夫曼树的特点: 

　　1、没有度为1的结点；

　　2、哈夫曼树的任意非叶节点的左右子树交换后仍是哈夫曼树；

　　3、n个叶子结点的哈夫曼树共有2n-1个结点(由没有度为1的结点推出， n₀+n₁+n₂ = 2*n₀-1)；

　　4、对同一组权值{w1 ,w2 , …… , wn}，存在不同构的两棵哈夫曼树；

　　5、外部结点的个数比内部结点的个数多一；

　　二、堆的两个特性

结构性：用数组表示的完全二叉树； 

有序性：任一结点的关键字是其子树所有结点的最大值(或最小值)

（堆的结点的子结点之间没有关系）

　　1、堆的操作

typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */
 
#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */
 
MaxHeap CreateHeap( int MaxSize )
{ /* 创建容量为MaxSize的空的最大堆 */
 
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/
 
    return H;
}
 
bool IsFull( MaxHeap H )
{
    return (H->Size == H->Capacity);
}
 
bool Insert( MaxHeap H, ElementType X )
{ /* 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵 */
    int i;
  
    if ( IsFull(H) ) { 
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */
    for ( ; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; /* 上滤X */
    H->Data[i] = X; /* 将X插入 */
    return true;
}
 
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
 
bool IsEmpty( MaxHeap H )
{
    return (H->Size == 0);
}
 
ElementType DeleteMax( MaxHeap H )
{ /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */
    int Parent, Child;
    ElementType MaxItem, X;
 
    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }
 
    MaxItem = H->Data[1]; /* 取出根结点存放的最大值 */
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 */
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
 
    return MaxItem;
} 
 
/*----------- 建造最大堆 -----------*/
void PercDown( MaxHeap H, int p )
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
 
    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}
 
void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
 
    int i;
 
    /* 从最后一个结点的父节点开始，到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

　　2、堆的操作实例

堆的路径，将一系列给定数字插入一个初始为空的小顶堆H[]。

随后对任意给 定的下标`i`，打印从H[i]到根结点的路径。

　　

#include <stdio.h>
/* 1.定义堆H */
#define MAXN 1001
#define MINH -10001
int H[MAXN], size;//堆,堆的大小
/* 2.堆的初始化 */
void Create ()
{
    size = 0;
    H[0] = MINH;/*设置“岗哨”*/    
}
/* 3.堆插入 */
void Insert ( int X )
{
    /* 省略检查堆是否已满 */
    int i; //46 23 26 24 10
    /* 
        下标从1开始,逐个插入,
        插入过程,从后向前,逐个与其父结点比较
        父结点大, 上滤X
        1  2  3  4  5 
        46               <-46  1/2==0  0
        23 46            <-23  2/2==1  1 0
        23 46 26         <-26  3/2==1  1 0
        23 24 26 46      <-24  4/2==2  2 1 0
        10 23 26 46 24   <-10  5/2==2  2 1 0
    */
    for (i=++size; H[i/2] > X; i/=2)
        H[i] = H[i/2];
    H[i] = X;//将X插入H
}

int main()
{    
/* 
    读入n和m
    根据输入序列建堆
    对m个要求：打印到根的路径
    5 3
    46 23 26 24 10
    5 4 3
 */    
    int n, m, x, i, j;
    scanf("%d%d", &n, &m);
    Create(); /* 堆初始化 */
    for (i=0; i<n; i++) { 
        scanf("%d", &x);
        Insert(x); /*以逐个插入方式建堆 */
    }
    
    /* for(int i=1; i<=n; ++i)
        printf("%3d",H[i]); */
    
    /* m个结点 */
    for (i=0; i<m; i++) 
    {
        scanf("%d", &j);//具体结点
        printf("%d", H[j]);
         /*向根方向输出各结点*/
        while (j>1) {
            j /= 2;
            printf(" %d", H[j]);
        }
        printf("
");
    }
    return 0;
}

　　三、C++  根据给定的权值创建，哈夫曼树  (用到优先队列，贪心算法，青岛大学mooc)

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct Node{
    int data;
    Node* left;
    Node* right;
    Node(){ left = right= NULL;}
    Node(int data){
        this->data = data;
        left = right = NULL;
    }
};
struct HuffmanTree{
    Node* root;
    HuffmanTree(){root = NULL;}
    HuffmanTree(int weight){
        root = new Node(weight);        
    }
    HuffmanTree(vector<HuffmanTree> &nodes){
        priority_queue<HuffmanTree, vector<HuffmanTree>, 
            greater<HuffmanTree>> q(nodes.begin(),nodes.end());
        HuffmanTree tmp;
        for(int i=1; i<nodes.size();++i){
            tmp.root =  new Node();
            tmp.root->left = q.top().root; q.pop();
            tmp.root->right = q.top().root; q.pop();
            tmp.root->data = tmp.root->left->data + tmp.root->right->data;
            q.push(tmp);
        }
        root = q.top().root;
    }
    bool operator > (const HuffmanTree &t) const{
        return this->root->data > t.root->data;
    }
    void print(){
        rprint(root,0);
    }
    void rprint(Node* r, int depth){
        for(int i=0; i<depth; ++i) cout<<"  ";
        if(!r) cout<<"[/]"<<endl;
        else{
            cout<<r->data<<endl;
            rprint(r->left, depth+1);
            rprint(r->right,depth+1);
        }
    }
};

int main()
{
    int nv,weight;
    cin>>nv;
    vector<HuffmanTree> nodes;
    for(int i=0; i<nv; ++i){
        cin>>weight;
        nodes.emplace_back(weight);
    }
    HuffmanTree ht(nodes);
    ht.print();
    return 0;
}
/*
7
10 15 12 3 4 13 1 
 */