最小优先队列 解决TopK问题

#include <vector>
#include <algorithm>
#include <limits>
#include <iostream>
using namespace std;

//////// 优先队列
#define  MAX_HEAP    300
class PriorityHeap
{
public:
PriorityHeap();
~PriorityHeap();

bool  empty();
int   size();
int   top();
void  push(int nValue);
int   pop();
private:
int				GetParentIndex(int nIndex);
const int&		GetParentValue(int nIndex);
int             GetLeftIndex(int nIndex);
int             GetRightIndex(int nIndex);
void            AdjustHeap(int nIndex);               // 调整根节点为nIndex的子树  前提是left(nIndex) right(nIndex)都是大顶堆

int  heap[MAX_HEAP];
int  heapSize;
};

PriorityHeap::PriorityHeap()
{
memset(heap, 0, sizeof(heap));
heapSize = 0;
}

PriorityHeap::~PriorityHeap()
{

}

bool PriorityHeap::empty()
{
return heapSize > 0 ? false : true;
}

const int& PriorityHeap::GetParentValue(int nIndex)
{
if (nIndex < 0 || nIndex >= heapSize)
{
return 0;
}

int nParentIndex = GetParentIndex(nIndex);
return heap[nParentIndex];
}

int PriorityHeap::GetParentIndex(int nIndex)
{
//return nIndex/2 - 1 > 0 ? nIndex/2 - 1 : 0;
return (nIndex+1)/2 - 1;
}

int PriorityHeap::GetLeftIndex(int nIndex)
{
return 2*nIndex + 1;
}

int PriorityHeap::GetRightIndex(int nIndex)
{
return 2*nIndex + 2;
}

void PriorityHeap::push(int nValue)
{
heapSize = heapSize + 1;
int heapIndex = heapSize -1;

heap[heapIndex] = nValue;
int nParentIndex = GetParentIndex(heapIndex);
while(heapIndex > 0 && heap[nParentIndex] > heap[heapIndex])
{
int nTemp = heap[heapIndex];
heap[heapIndex] = heap[nParentIndex];
heap[nParentIndex] = nTemp;

heapIndex = nParentIndex;
nParentIndex = GetParentIndex(heapIndex);
}
}

int PriorityHeap::top()
{
return heap[0];
}

int PriorityHeap::size()
{
return heapSize;
}

int PriorityHeap::pop()
{
int nRoot = heap[0];
heapSize = heapSize - 1;
heap[0] = heap[heapSize];
AdjustHeap(0);
return nRoot;
}

void PriorityHeap::AdjustHeap(int nIndex)
{
int largestIndex = nIndex;
int leftIndex = GetLeftIndex(nIndex);
int rightIndex = GetRightIndex(nIndex);

if (leftIndex < heapSize && heap[leftIndex] < heap[largestIndex])
{
largestIndex = leftIndex;
}

if (rightIndex < heapSize && heap[rightIndex] < heap[largestIndex])
{
largestIndex = rightIndex;
}

if (largestIndex != nIndex)
{
int nTemp = heap[largestIndex];
heap[largestIndex] = heap[nIndex];
heap[nIndex] = nTemp;
AdjustHeap(largestIndex);
}
}

void FindTopK()
{
int nValue;
int k;
PriorityHeap heap;

cin >> k;
while (cin >> nValue)
{
if (heap.size() < k)
{
heap.push(nValue);
}
else if(nValue > heap.top())
{
heap.pop();
heap.push(nValue);
}
}
while(!heap.empty())
{
cout << heap.pop() << " " << endl;
}
system("pause");
}

int main()
{
PriorityHeap  Heap;
int nValue;
while (cin >> nValue)
{
Heap.push(nValue);
}

while(!Heap.empty())
{
cout << Heap.pop() << " " << endl;
}

FindTopK();
return 0;
}