数据结构C++实现基本的堆

#pragma once

#include<vector>

#include<queue>

#include<cassert>

#include<iostream>

using namespace std;

//仿函数实现在建堆时确定（大小堆）

template<class T>

struct Greater

{

bool operator()(const T& left,const T& right)

{

return left > right;

}

};

template<class T>

struct Less

{

bool operator()(const T& left, const T& right)

{

return left < right;

}

};

template<class T,class Compare = Less<T>>//默认建小堆

class Heap

{

public:

Heap()

{

}

Heap(const T* array, size_t size)

{

assert(array);

for (size_t i = 0; i < size; ++i)

{

_vec.push_back(array[i]);

}

for (int i = _vec.size() / 2 - 1; i >= 0; --i)

{

_AdjustDown(_vec, i, _vec.size());

}

}

Heap(const vector<T>& vec)

{

_vec.swap(vec);

for (int i = _vec.size() / 2 - 1; i >= 0; --i)

{

_AdjustDown(_vec, i, _vec.size());

}

}

void Push(const T& x)

{

_vec.push_back(x);

if (_vec.size() > 0)

_AdjustUp(_vec, _vec.size() - 1);

}

void Pop()

{

swap(_vec[0], _vec[_vec.size() - 1]);

_vec.pop_back();

_AdjustDown(_vec, 0, _vec.size());

}

const T& GetTop()

{

assert(_vec.size() > 0);

return _vec[0];

}

bool Empty()

{

return _vec.empty();

}

size_t Size()

{

return _vec.size();

}

private:

void _AdjustDown(vector<T>& vec,int root,int size)

{

int left = root * 2 + 1;

while (left < size)

{

if (left+1 < size && Compare()(vec[left+1], vec[left]))

++left;

if (Compare()(vec[left], vec[root]))

{

swap(vec[left], vec[root]);

root = left;

left = root * 2 + 1;

}

else

break;

}

}

void _AdjustUp(vector<T>& vec,int index)

{

int parent = index >> 1;

while (Compare()(vec[index], vec[parent]))

{

swap(vec[index], vec[parent]);

index = parent;

parent = index >> 1;

}

}

protected:

vector<T> _vec;//底层使用vector来实现

};

void test()

{

int arr[] = { 1, 2, 8, 9, 7, 4, 6, 5, 11, 10 };

Heap<int> h(arr, sizeof(arr) / sizeof(arr[0]));

h.Push(0);

h.Pop();

cout << h.GetTop() << endl;

h.Pop();

}