数据结构--大小堆

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树 的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2*i+1 且 Ki<= K2*i+2  (Ki >= K2*i+1 且 Ki >= K2*i+2) i = 0，1，2…，则称这个堆为最小堆(或最大堆)。

最大堆和最小堆是二叉堆的两种形式。

最大堆：根结点的键值是所有堆结点键值中最大者，且每个结点的值都比其孩子的值大。

最小堆：根结点的键值是所有堆结点键值中最小者，且每个结点的值都比其孩子的值小。

这样我们就能根据图大小堆的规则构建大小堆了

我们根据数组arr 最终要创建这样一个树

下面图示流程是 创建 最小堆的过程 ：

其实看懂了上面的流程，最小堆的代码也就出来了。

下面把 最大堆的代码就直接放在这了，当然还有一些操作，如：插入、删除、堆顶元素之类的 

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;

//Use a vector create Heap
template <class T >
class HeapGeater
{
public:
	HeapGeater()
	{}
	HeapGeater(const T arr[], size_t size) //size is Elem_count
	{
		assert(arr);
		//push data
		_heap.resize(size);
		for (size_t index = 0; index < size; index++)
		{
			//_heap.push_back(arr[index]);
			_heap[index] = arr[index];
		}
		size_t Root = size / 2 - 1; // the last Leef_Node of Root
		for (int index = Root; index >= 0; index--)
		{
			_AdjustDown(index);
		}
	}
	bool Empty()
	{
		return _heap.empty();
	}
	size_t Size()
	{
		return _heap.size();
	}

	T& Top()const
	{
		assert(!Empty());
		return _heap[0];
	}
	const T&Top()
	{
		assert(!Empty());
		return _heap[0];
	}
	
	void Insert(const T& data)
	{
		assert(!Empty());
		T tmp = _heap[Size() - 1];
		_heap.push_back(data);
		if (data > tmp)
		{
			int  Root = Size() / 2 - 1; // the last Leef_Node of Root
			for (int index = Root ; index > 0; index--)
			{
				AdjustUp(index);
			}
		}
	}

	void Remove(const T& data)
	{
		assert(!Empty());
		_heap[0] = _heap[Size() - 1];
		_heap.resize(Size()-1 );

	   int Root = Size() / 2 - 1; // the last Leef_Node of Root
		for (int index = Root; index >= 0; index--)
		{
			_AdjustDown(index);
		}
	}

protected:
	void  _AdjustDown(size_t  Root)//adjust to Max_heap
	{
		size_t Child = Root * 2 + 1;// find the LeftChild
		while (Child < _heap.size())
		{
			// find Max  between left_elem and right_elem
			if ((Child + 1 < _heap.size()) && _heap[Child + 1] > _heap[Child])
			{
				//std::swap(_heap[Child + 1], _heap[Child]);
				Child = Child + 1;
			}
			//confirm The root is MAx
			if (_heap[Child] > _heap[Root])
			{
				std::swap(_heap[Child], _heap[Root]);
				Root = Child;
				Child = Child*2 + 1;
			}
			else
			{
				break;
			}
		}//end  while
	}
	void AdjustUp(int Root)
	{
		int child = Size() - 1; //Find the inserted data 
		while ( Root >= 0 && _heap[Root] < _heap[child])
		{
			swap(_heap[Root], _heap[child]);	
			child = Root;
			Root = (Root - 1) / 2;		
		}
	}
private:
	std::vector<T> _heap;
};


/********Test Code**********/
void test_heapGeater()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	HeapGeater<int>  ap(arr,8);
	cout <<"****************" << endl;

	cout<< ap.Size()<<endl;
	ap.Insert(99);
	cout << ap.Top() << endl;
	cout << ap.Size() << endl;
	ap.Remove(8);
	cout << ap.Top() << endl;
	cout << ap.Size() << endl;
}