堆 堆元素的插入 最小堆 堆元素的移除

#ifndef _HEAP_H
#define _HEAP_H
template<class Type>
void exchange(Type *a,Type *b)
{
    Type tm=*a;
    *a=*b;
    *b=tm;
}
template<class Type>
class heap
{
public:
heap()
{
    capacity=DEFAULT_SIZE;
    base=new Type[capacity];
    size=0;
}
heap(Type *ar,int sz)
{
    capacity=sz>DEFAULT_SIZE?sz:DEFAULT_SIZE;
    base=new Type[capacity];
    for(int i=0;i<sz;++i)
    base[i]=ar[i];
    size=sz;
    for(int i=size/2-1;i>=0;--i)
    siftdown(i,size-1);
}
~heap()
{
    delete []base;
    capacity=size=0;
}
bool full()
{
return size==capacity;
}
bool   empty()
{
return size==0;
}
void showHeap()
{
    for(int i=0;i<size;++i)
    cout<<base[i]<<"  ";
    cout<<endl;
}

void siftdown(int start,int end)
{
    int min=2*start+1;
    if(2*start+2<=end&&base[2*start+2]<base[2*start+1])
    min=start*2+2;
    if(base[min]>base[start])
    min=start;
    exchange(&base[min],&base[start]);
    if(min!=start&&2*min+1<end)
    siftdown(min,end);
}
void siftup()
{
    for(int i=size-1;(i-1)/2>=0;)
    {
        if(base[i]<base[(i-1)/2])
        {
            exchange(&base[i],&base[(i-1)/2]);
            i=(i-1)/2;
        }
        else
        break;
    }

}
void Remove();
void Insert(Type x);
private:
enum{DEFAULT_SIZE=20};
Type *base;
int capacity;
int size;
};
template<class Type>
void heap<Type>::Remove()
{
if(!empty())
    {
        base[0]=base[--size];
        siftdown(0,size-1);
    }
}
template<class Type>
void heap<Type>::Insert(Type x)
{
    if(!full())
    {
        base[size++]=x;
        siftup();
    }
    else
    {
///
    }

}
#endif

稍微改动过的版本：

#pragma once

#include<iostream>
using namespace std;

template<class Type>
class MinHeap
{
public:
    MinHeap(int sz = DEFAULT_HEAP_SIZE)
    {
        capacity = sz > DEFAULT_HEAP_SIZE ? sz : DEFAULT_HEAP_SIZE;
        heap = new Type[capacity];
        size = 0;
    }
    MinHeap(Type ar[], int n)
    {
        capacity = n>DEFAULT_HEAP_SIZE?n:DEFAULT_HEAP_SIZE;
        heap = new Type[capacity];
        for(int i=0; i<n; ++i)
        {
            heap[i] = ar[i];
        }
        size = n;
        int curpos = n/2-1;
        while(curpos >= 0)
        {
            siftDown(curpos,size-1);
            curpos--;
        }
    }
    ~MinHeap()
    {
        delete []heap;
        capacity = size = 0;
    }
public:
    bool IsFull()const
    {
        return size >= capacity;
    }
    bool IsEmpty()const
    {
        return size == 0;
    }
public:
    void ShowHeap()const
    {
        for(int i=0; i<size;++i)
        {
            cout<<heap[i]<<" ";
        }
        cout<<endl;
    }
public:
    void Insert(Type x)
    {
        if(!IsFull())
        {
            heap[size] = x;
            siftUp(size);
            size++;
        }
    }
    Type Remove()
    {
        Type val;
        if(!IsEmpty())
        {
            val = heap[0];
            heap[0] = heap[size-1];
            size--;
            siftDown(0,size-1);
        }
        return val;
    }
private:
    void siftDown(int start, int m);
    void siftUp(int start);
private:
    enum{DEFAULT_HEAP_SIZE=20};
    Type *heap;
    int capacity;
    int size;
};

template<class Type>
void MinHeap<Type>::siftDown(int start, int m)//非递归版本的
{
    int i = start;
    int j = 2*i+1;
    while(j <= m)
    {
        if(j+1<=m && heap[j]>heap[j+1])
            j = j+1;
        if(heap[j] < heap[i])
        {
            Type tmp = heap[j];
            heap[j] = heap[i];
            heap[i] = tmp;
        }
        else
            break;
        i = j;
        j = 2*i+1;
    }
}

template<class Type>
void MinHeap<Type>::siftUp(int start)
{
    int j = start; //
    int i = (j-1)/2; //

    while(j > 0)
    {
        if(heap[i] < heap[j])
            break;
        else
        {
            Type tmp = heap[i];
            heap[i] = heap[j];
            heap[j] = tmp;
        }
        j = i;
        i = (j-1)/2;
    }
}