堆应用---构造Huffman树(C++实现)

堆：
　　堆是STL中priority_queue的最高效的实现方式（关于priority_queue的用法：http://www.cnblogs.com/flyoung2008/articles/2136485.html）。

　　主要分为大根堆和小根堆。

　　是一棵完全二叉树。

　　堆的一次插入删除调整的时间复杂度都是logn。

Huffman树：

　　又称最优二叉树（带权路径中），带权路径长度最小的二叉树应是权值大的外节点离根结点最近的扩充二叉树（权值都在叶节点的二叉树）就是Huffman树。

算法：

　　将权值对应的节点全部放入一个小根堆中。

　　每次取出堆顶的两个节点，构造成一个新的节点，循环n-1次（n为节点数量）。

代码如下：

　　

 #include<iostream>
 using namespace std;
 template<class T>
 struct TreeNode{
     T data;//节点值
     TreeNode<T> *left,*right,*parent;//左右孩子
     TreeNode(){
         left=NULL;
         right=NULL;
         parent=NULL;
     }
     TreeNode(T x,TreeNode<T> *l=NULL,TreeNode<T> *r=NULL,TreeNode<T> *p=NULL){
         data=x;
         left=l;
         right=r;
         parent=p;
     }
     bool operator <=(TreeNode<T> &r){
         return data<=r.data;
     }
     bool operator <(TreeNode<T> &r){
         return data<r.data;
     }
     bool operator >=(TreeNode<T> &r){
         return data>=r.data;
     }
     bool operator >(TreeNode<T> &r){
         return data>r.data;
     }
 }; 

 template<class T>
 class MinHeap{//最小堆
     private:
         T *heap;//堆数组
         int maxSize;//堆最大容量
         int currentSize;//当前容量
     public:
         MinHeap(int sz=){
             maxSize=sz;
             heap=new T[maxSize];
             currentSize=;
         }
         ~MinHeap(){
             delete []heap;
         }
         T* getHeap(){
             return heap;
         }
         void siftDown(int start,int m){//向下调整堆数组
             int i=start;
             int j=*i+;
             T temp=heap[i];
             while(j<=m){
                 if(j<m&&*heap[j]>*heap[j+]) j++;
                 if(*temp<=*heap[j]) break;
                 heap[i]=heap[j];
                 i=j;
                 j=*j+;
             }
             heap[i]=temp;
         }
         void siftUp(int start){//向上调整堆数组
             int i=start;
             int j=(i-)/;
             T temp=heap[i];
             while(i>){
                 if(*temp>=*heap[j]) break;
                 heap[i]=heap[j];
                 i=j;
                 j=(i-)/;
             }
             heap[i]=temp;
         }
         bool insert(const T& x){//插入元素
             if(currentSize==maxSize) return false;
             heap[currentSize]=x;
             siftUp(currentSize);
             currentSize++;
             return true;
         }
         bool remove(T& x){//删除元素
             if(!currentSize) return false;
             x=heap[];
             heap[]=heap[currentSize-];
             currentSize--;
             siftDown(,currentSize-);
             return true;
         }
 };

 template<class T>
 class HuffmanTree{
     public:
         HuffmanTree(T w[],int n){//构造Huffman树
             TreeNode<T> *temp,*first,*second,*parent;
             MinHeap <TreeNode<T>* >hp;
             for(int i=;i<n;i++){
                 temp=new TreeNode<T>(w[i]);
                 hp.insert(temp);
             }
             for(int i=;i<n-;i++){
                 first=new TreeNode<T>;
                 second=new TreeNode<T>;
                 hp.remove(first);
                 hp.remove(second);
                 parent=new TreeNode<T>;
                 merge(first,second,parent);
                 hp.insert(parent);
             }
             root=parent;
         }
         void merge(TreeNode<T> *first,TreeNode<T> *second,TreeNode<T>* parent){//选取两个最小带权节点合并
                 parent->left=first;
                 parent->right=second;
                 parent->data=first->data+second->data;
                 first->parent=parent;
                 second->parent=parent;
         }
         ~HuffmanTree(){
             destroy(root);
         }
         void destroy(TreeNode<T> *subTree){//递归删除以subTree为根的所有结点
             if(subTree!=NULL){
                 destroy(subTree->left);
                 destroy(subTree->right);
                 delete subTree;
             }
         }
         void preOrder(TreeNode<T> *subTree){//前序遍历
             if(subTree!=NULL){
                 cout<<subTree->data<<" ";
                 preOrder(subTree->left);
                 preOrder(subTree->right);
             }
         }
         TreeNode<T> *getRoot(){
             return root;
         }
     private:
         TreeNode<T> *root;
 };    

 int main(){
     int N,*w;
     cout<<"输入元素总数："<<endl;
     cin>>N;
     w=new int[N];
     cout<<"输入这组整数："<<endl;
     for(int i=;i<N;i++){
         cin>>w[i];
     }
     HuffmanTree<int> *ht=new HuffmanTree<int>(w,N);
     TreeNode<int> *root=ht->getRoot();
     cout<<"Huffman树前序遍历结果:"<<endl;
     ht->preOrder(root);
     delete ht,w;
     return ;
 }