#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;
}
}