一个堆实现

//a strong type heap.
#define LEFT_CHILD_POS(x) (x<<1)
#define RIGHT_CHILD_POS(x) ((x<<1)+1)
#define RIGHT_SUBLING_POS(x) (x|1)
#define LEFT_SUBLING_POS(x) (x&0xFFFFFFFFE)
#define PARENT_POS(x) (x>>1)


template<typename VALUE_TYPE,typename CONTENT_TYPE,bool IS_MAX>
class Heap
{
public:
struct Elem
{
VALUE_TYPE value;
CONTENT_TYPE content;
};


Heap(int max_size)
{
assert(pow(2.0,floor(log((double)max_size)/log(2.0))) == max_size);
elem_count_ = 1;
capacity_ = max_size+1;
elem_ptr_ = new Elem[max_size+1];
}


~Heap()
{
delete []elem_ptr_;
}


void push(VALUE_TYPE value,const CONTENT_TYPE& content)
{
assert(elem_count_ < capacity_);
elem_ptr_[elem_count_].value = value;
elem_ptr_[elem_count_].content = content;
move_up(elem_count_++);
}

VALUE_TYPE pop(CONTENT_TYPE &content)
{
assert(size());
VALUE_TYPE res = elem_ptr_[1].value;
content = elem_ptr_[1].content ;
elem_ptr_[1] = elem_ptr_[--elem_count_];
move_down(1);
return res;
}

int size(void)
{
return elem_count_ - 1;
}

int capacity(void)
{
return capacity_-1;
}
private:
inline bool big_than(VALUE_TYPE v1,VALUE_TYPE v2)
{
if (IS_MAX)
{
return v1 > v2;
}else
{
return v1 < v2;
}
}


inline void swap(int p1,int p2)
{
Elem tem = elem_ptr_[p1];
elem_ptr_[p1] = elem_ptr_[p2];
elem_ptr_[p2] = tem;
}


void move_down(int i)
{
int lp = LEFT_CHILD_POS(i);
int rsp = RIGHT_SUBLING_POS(i);

if (rsp < elem_count_ 
&& big_than(elem_ptr_[rsp].value , elem_ptr_[i].value)
&& (lp >= elem_count_ || big_than(elem_ptr_[rsp].value , elem_ptr_[lp].value)))
{
swap(i,rsp);
move_down(rsp);
}else if(lp < elem_count_ && big_than(elem_ptr_[lp].value , elem_ptr_[i].value))
{
swap(i,lp);
move_down(lp);
}
}


void move_up(int i)
{


int lsp = LEFT_SUBLING_POS(i);
if (lsp && big_than(elem_ptr_[i].value , elem_ptr_[lsp].value))
{
swap(i,lsp);
move_up(lsp);
}else
{
int pp = PARENT_POS(i);
if (pp && big_than(elem_ptr_[i].value , elem_ptr_[pp].value))
{
swap(i,pp);
move_up(pp);
}
}
}


Elem *elem_ptr_;
int capacity_;
int elem_count_;

};

/*

coding is so hard, can this be more simple?

*/