建堆

堆数据结构是一种数组对象，它可以被视为一颗完全二叉树结构

堆结构的二叉树存储是：

最大堆：每个父节点都大于孩子结点

最小堆：每个父节点都小于孩子结点

vector<int>_arr：创建vector对象，使得数组不是一个确定的大小，当其需要增大容量时会自动增大

代码中用到了向下调整和向上调整的思想

#include<iostream>
#include<vector>
using namespace std;
template<class T>
class Heap
{
public:
	Heap(T* arr,size_t size)
	{
		_arr.reserve(size);//_arr的初始化
		for(size_t i=0;i<size;i++)
		{
			_arr.push_back(arr[i]);//把arr同样的给_arr
		}
		for(int i=(_arr.size()-2)/2;i>=0;--i)//从最后一个非叶子结点开始，数组建堆
		{
			AdjustDown(i);
		}
	}
	void push(const T& data)//在堆里面插入一个元素
	{
		_arr.push_back(data);
		AdjustUp(_arr.size()-1);
	}
	void pop()//pop堆顶的元素
	{
		swap(_arr[0],_arr[_arr.size()-1]);//堆顶元素和最后一个元素交换
		_arr.pop_back();//pop掉最后一个元素
		AdjustDown(0);
	}
	void Display()
	{
		  for(size_t i=0;i<_arr.size();i++)
		  {
			  cout<<_arr[i]<<" ";
		  }
		  cout<<endl;
	}
	void AdjustDown(size_t root)
	{
		size_t parent=root;
		size_t child=2*parent+1;
		while(child<_arr.size())
		{
			if(child+1<_arr.size()&&_arr[child+1]>_arr[child])
			{
				++child;
			}
			if(_arr[child]>_arr[parent])
			{
				swap(_arr[child],_arr[parent]);
				parent=child;
				child=2*parent+1;
			}
			else
			{
				break;
			}
		}
	}
	void AdjustUp(size_t root)
	{
		size_t child=root;
		size_t parent=(child-1)/2;
		while(parent>=0)
		{
			if(_arr[child]>_arr[parent])
			{
				swap(_arr[child],_arr[parent]);
				child=parent;
				parent=(child-1)/2;
			}
			else
			{
				break;
			}
		}
	}
	size_t Size()
	{
		return _arr.size();
	}
	bool Empty()
	{
		return _arr.empty();
	}
	const T& Top()
	{
		return _arr[0];
	}
private:
	vector<T>_arr;//vector 就相当于类中的一个自定义类型的数组

};
void test()
{
	int arr[]={10,16,18,12,11,13,15,17,14,19};
	int size=sizeof(arr)/sizeof(arr[0]);
	Heap<int> hp(arr,size);//声明类后，定义了一个对象；
	hp.Display();
	hp.push(20);
	hp.Display();
	hp.pop();
	hp.Display();
	cout<<"size="<<hp.Size()<<endl;
	cout<<"empty ?"<<hp.Empty()<<endl;
	cout<<"top="<<hp.Top()<<endl;
}
int main()
{
	test();
	system("pause");
	return 0;

}