堆的实现，提供 min_heap and max_heap功能

主要完成维护一个min-heap or max-heap，如果push的个数超过heap的大小，则进行替换，依赖于compare函数。

其中min-heap需要定义 return a < b; max-heap: return a > b

在空间不够的情况下，min-heap保留最大的k个元素，max-heap相反。

code:

template<typename Type>

class LessThan

{

public:

bool operator()(const Type& first, const Type& second)

{

return first < second;

}

};

#ifndef _HEAP_H_

#define _HEAP_H_

#include "utility.h"

#include <string.h>

#define DEFAULT_BUFF_NUM 1000

namespace utility

{

//Compare, return a>b, 0,1,2,3 return a<b, 3,2,1,0

template<typename Type, typename Compare = LessThan<Type> >

class Heap

{

public:

Heap(int capacity = 0);

~Heap();

int push(const Type& type);

Type pop();

Type top();

int size();

int capacity();

bool empty();

private:

int ShiftUp();

int ShiftDown();

int Parent(int i);

int Left(int i);

int Right(int i);

private:

int mSize;

int mCapacity;

Type* mpHeap;

Compare mCompare;

};

template<typename Type, typename Compare>

int Heap<Type, Compare>::Parent(int i)

{

return int((i + 1) / 2) - 1;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::Left(int i)

{

return 2 * (i + 1) - 1;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::Right(int i)

{

return 2 * (i + 1);

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::ShiftUp()

{

// sucks

int i = mSize - 1;

while (i > 0)

{

int parent = Parent(i);

// need to modify

if (!mCompare(mpHeap[parent], mpHeap[i]))

{

Swap(mpHeap[parent], mpHeap[i]);

}

else

{

break;

}

i = parent;

}

return 0;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::ShiftDown()

{

// sucks

int i = 0;

while (i < mSize)

{

int left = Left(i);

int right = Right(i);

int modify = -1;

if ((right < mSize))

{

if (mCompare(mpHeap[left], mpHeap[right]))

{

modify = left;

}

else

{

modify = right;

}

}

else if (left < mSize)

{

modify = left;

}

if (modify < 0)

{

break;

}

if (!mCompare(mpHeap[i], mpHeap[modify]))

{

Swap(mpHeap[i], mpHeap[modify]);

}

else

{

break;

}

i = modify;

}

return 0;

}

template<typename Type, typename Compare>

Heap<Type, Compare>::Heap(int capactiy):

mSize(0),

mCapacity(capactiy),

mpHeap(NULL)

{

if (mCapacity <= 0)

{

mCapacity = DEFAULT_BUFF_NUM;

}

mpHeap = new Type[mCapacity];

memset(mpHeap, 0, mCapacity * sizeof(Type));

}

template<typename Type, typename Compare>

Heap<Type, Compare>::~Heap()

{

delete[] mpHeap;

mpHeap = NULL;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::push(const Type& type)

{

if (mSize < mCapacity)

{

mpHeap[mSize] = type;

++mSize;

ShiftUp();

}

else

{

// small element on the top

if (!mCompare(type, mpHeap[0]))

{

mpHeap[0] = type;

ShiftDown();

}

}

return 0;

}

template<typename Type, typename Compare>

Type Heap<Type, Compare>::top()

{

return mpHeap[0];

}

template<typename Type, typename Compare>

Type Heap<Type, Compare>::pop()

{

Type type = mpHeap[0];

if (mSize == 1)

{

--mSize;

return type;

}

mpHeap[0] = mpHeap[mSize - 1];

--mSize;

ShiftDown();

return type;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::size()

{

return mSize;

}

template<typename Type, typename Compare>

int Heap<Type, Compare>::capacity()

{

return mCapacity;

}

template<typename Type, typename Compare>

bool Heap<Type, Compare>::empty()

{

return mSize <= 0;

}

}

#endif