简单的堆实现

在学习了堆数据结构之后，本人用c++尝试实现了一个简单的堆数据结构，源代码及测试结果如下

源代码如下

#include <iostream>
#include <vector>

using namespace std;

class heap
{
public:
    heap(int flag):flag_(flag)
    {
        //flag==1 大根堆 flag==0 小根堆
        if(flag_==1)
        {
            heap_value_.push_back(INT_MAX);
        }
        else
        {
            heap_value_.push_back(INT_MIN);
        }
    }
    void push(int i)
    {
        if(flag_)
        {
            heap_value_.push_back(i);
            int pos=heap_value_.size()-1;
            while(heap_value_[pos]>heap_value_[pos/2])
            {
                swap(heap_value_[pos],heap_value_[pos/2]);
                pos=pos/2;
            }
        }
        else
        {
            heap_value_.push_back(i);
            int pos=heap_value_.size()-1;
            while(heap_value_[pos]<heap_value_[pos/2])
            {
                swap(heap_value_[pos],heap_value_[pos/2]);
                pos=pos/2;
            }
        }
    }
    void pop(void)
    {
        if(heap_value_.size()==1)
        {
            cout<<"The heap is empty! Please insert values"<<endl;
            return;
        }
        if(heap_value_.size()==2)
        {
            heap_value_.pop_back();
            return;
        }
        
        heap_value_[1]=heap_value_[heap_value_.size()-1];
        heap_value_.pop_back();
        
        int left;
        int right;
        int pos=1;

        if(flag_)
        {

            while(pos<heap_value_.size())
            {
                left=pos*2;
                right=pos*2+1;
                if(left<heap_value_.size()&&right<heap_value_.size())
                {
                    if(heap_value_[left]>heap_value_[right])
                    {
                        if(heap_value_[pos]>=heap_value_[left])
                        {
                            break;
                        }
                        swap(heap_value_[pos],heap_value_[left]);
                        pos=left;
                    }
                    else
                    {
                        if(heap_value_[pos]>=heap_value_[right])
                        {
                            break;
                        }
                        swap(heap_value_[pos],heap_value_[right]);
                        pos=right;
                    }
                }
                else if(left<heap_value_.size())
                {
                    if(heap_value_[pos]>=heap_value_[left])
                    {
                        break;
                    }
                    swap(heap_value_[pos],heap_value_[left]);
                    pos=left;
                }
                else
                {
                    if(heap_value_[pos]>=heap_value_[right])
                    {
                        break;
                    }
                    swap(heap_value_[pos],heap_value_[right]);
                    pos=right;
                }
            }
        }
        else
        {
            while(pos<heap_value_.size())
            {
                left=pos*2;
                right=pos*2+1;
                if(left<heap_value_.size()&&right<heap_value_.size())
                {
                    if(heap_value_[left]<heap_value_[right])
                    {
                        if(heap_value_[pos]<=heap_value_[left])
                        {
                            break;
                        }
                        swap(heap_value_[pos],heap_value_[left]);
                        pos=left;
                    }
                    else
                    {
                        if(heap_value_[pos]<=heap_value_[right])
                        {
                            break;
                        }
                        swap(heap_value_[pos],heap_value_[right]);
                        pos=right;
                    }
                }
                else if(left<heap_value_.size())
                {
                    if(heap_value_[pos]<=heap_value_[left])
                    {
                        break;
                    }
                    swap(heap_value_[pos],heap_value_[left]);
                    pos=left;
                }
                else
                {
                    if(heap_value_[pos]<=heap_value_[right])
                    {
                        break;
                    }
                    swap(heap_value_[pos],heap_value_[right]);
                    pos=right;
                }
            }
        }
    }
    int top(void)
    {
        if(heap_value_.size()==1)
        {
            cout<<"The heap is empty! Please insert values"<<endl;
            return 0;
        }
        return heap_value_[1];
    }
    int size(void)
    {
        return heap_value_.size()-1;
    }
private:
    vector<int> heap_value_;
    int flag_;
};

int main()
{
    heap h(1);

    h.push(1);
    h.push(19);
    h.push(15);
    h.push(2);
    h.push(3);
    h.push(100);
    h.push(101);
    h.push(102);
    
    int n=h.size();
    for(int i=0;i<n;i++)
    {
        cout<<h.top()<<" "<<h.size()<<endl;
        h.pop();
    }
}

测试结果如下

102 8
101 7
100 6
19 5
19 4
15 3
3 2
2 1