小根堆类

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
using namespace std;

template <class T>
class MinHeap{
private:
    T *HeapArray;
    int current_size;
    int max_size;
public:
    MinHeap(int n);
    ~MinHeap();
    void InitHeap();
    void SiftDown(int pos);
    void SiftUp(int pos);
    void BuildHeap();
    bool Insert(T data);
    bool MoveMin();
    void display();
};

template <class T>
MinHeap <T>::MinHeap(int n){
    HeapArray = new T[n];
    max_size = n;
    current_size = 0;
}

template <class T>
MinHeap <T>::~MinHeap(){
    delete []HeapArray;
}

template <class T>
void MinHeap <T>::InitHeap(){
    int init_len;
    T temp;
    cout<<"Input the init_num :";
    cin>>init_len;
    current_size=init_len;
    for(int i=0;i<init_len;i++){
        cin>>HeapArray[i];
    }
}

template <class T>
void MinHeap <T>::SiftDown(int pos){
    while(pos<current_size){
        if(2*pos+2<current_size){
            T temp=min(HeapArray[pos],min(HeapArray[pos*2+1],HeapArray[pos*2+2]));
            if(temp==HeapArray[pos]) break;
            else if(temp==HeapArray[pos*2+1]){
                HeapArray[pos*2+1]=HeapArray[pos];
                HeapArray[pos]=temp;
                pos=pos*2+1;
                continue;
            }
            else{
                HeapArray[pos*2+2]=HeapArray[pos];
                HeapArray[pos]=temp;
                pos=pos*2+2;
                continue;
            }
        }
        else{
            if(HeapArray[pos]>HeapArray[pos*2+1]){
                T temp=HeapArray[pos];
                HeapArray[pos]=HeapArray[pos*2+1];
                HeapArray[pos*2+1]=temp;
                break;
            }
            else break;
        }
    }
}

template <class T>
void MinHeap <T>::SiftUp(int pos){
    while(pos>=0){
        if(HeapArray[pos]<HeapArray[(pos-1)/2]){
            T temp=HeapArray[pos];
            HeapArray[pos]=HeapArray[(pos-1)/2];
            HeapArray[(pos-1)/2]=temp;
            pos=(pos-1)/2;
        }
        else break;
    }
}

template <class T>
void MinHeap <T>::BuildHeap(){
    InitHeap();
    for(int i=(current_size-1)/2;i>=0;i--){
        SiftDown(i);
    }
}

template <class T>
bool MinHeap <T>::Insert(T data){
    if(current_size<max_size){
        HeapArray[current_size]=data;
        SiftUp(current_size-1);
        current_size++;
        return true;
    }
    else return false;
}

template <class T>
bool MinHeap <T>::MoveMin(){
    if(current_size==0) return false;
    else{
        HeapArray[0]=HeapArray[current_size-1];
        current_size--;
        SiftDown(0);
    }
}

template <class T>
void MinHeap <T>::display(){
    for(int i=0;i<current_size;i++)
        cout<<HeapArray[i]<<" ";
    cout<<endl;
}

int main(){
    int len;
    cout<<"Input the max_size :";
    cin>>len;
    MinHeap <string> opt(len);
    string temp;
    opt.display();
    opt.BuildHeap();
    opt.display();
    cout<<"Input the data you want to insret :";
    cin>>temp;
    opt.Insert(temp);
    opt.display();
    cout<<"Delete the Minist data :";
    opt.MoveMin();
    opt.display();
    system("pause");
    return 0;
}