堆

一、堆的概念

堆数据结构是一种数组对象，同时也是一棵完全二叉树

堆得存储结构：

（1）大堆：每个父节点的关键码都大于孩子节点

（2）小堆：每个父节点的关键码都小于孩子节点

二、堆的创建

建立大堆分为两步：

（1）将数据放入堆中

		for (size_t i = 0; i < n; i++)
		{
			_a.push_back(a[i]);
		}for (size_t i = 0; i < n; i++)
		{
			_a.push_back(a[i]);
		}

（2）调整堆

大堆——向下调整

小堆——向上调整

	void AdjustDown(size_t root)//向下调整
	{
		int parent = root;
		int child = parent * 2 + 1;//左孩子存在
		//while循环结束有两种情况：1父亲节点大于孩子节点；
				//2父亲节点小于孩子节点，不断调整，直至叶子节点
		while (child < _a.size())
		{
			//选出左右孩子中较大的
			if ((child + 1 < _a.size ())&&(_a[child] > _a[child + 1]))
			{
				//左右孩子节点都存在
				++child;
			}

			if (_a[child] > _a[parent])//孩子节点大于父亲节点
			{
				swap(_a[child], _a[parent]);
				//让其循环
				parent = child;
				child = parent * 2 + 1;
			}
			else//父亲节点大于孩子节点
			{
				break;
			}
		}
	}

三、堆的插入

        堆每次插入都是在已经建好的堆的最后面；之后判断是否破坏了堆的结构，若破坏了，则进行调整。

        void Push(const T& x)//尾插
	{
		_a.push_back(x);
		AdjustUp(_a.size() - 1);
	}

大堆——自上至下进行调整

小堆——自下至上进行调整

	void AdjustUp(size_t child)//向上调整
	{
		size_t parent = (child - 1) / 2;
		while (child > 0)//child大于堆顶
		{
			if (_a[child] > _a[parent])
			{
				swap(_a[child], _a[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				break;
			}
		}
	}

四、删除

堆顶元素

大堆——最大值

小堆——最小值

从堆中删除堆顶元素

（1）移除堆顶元素之后，用堆的最后一个节点填补取走的元素 ，并将堆的实际元素个数减1。

 （2）判断堆的结构，若被破坏，则进行向上调整    

	void Pop()//删除堆顶的元素
	{
		//交换堆顶元素和最后一个元素
		swap(_a[0], _a[_a.size() - 1]);
		//删除最后一个元素
		_a.pop_back();
		//进行向小调整（堆顶元素）
		AdjustDown(0);
	}

五、堆的应用

1、100w个数中找出最大的前K个数

首先建立一个元素为K的小堆，然后开始遍历数据，如果比根节点大则将根节点pop出去、将该数据push进堆中，之后进行调整堆，调整好的堆顶元素就是堆中最小的元素。以此类推，当数据全部遍历完之后，堆中的元素就是我们想要的数据。

2、堆排序

#include<assert.h>
#include<time.h>
#include<windows.h>
void AdjustDown(int *heap, int k, int root)//向下调整
//调整的堆heap,堆的大小k,从root位置开始调整
{
	assert(heap);
	int parent = root;
	int child = parent * 2 + 1;
	while (child < k)
	{
		if ((child + 1 < k) && (heap[child] < heap[child + 1]))
		{
			++child;
		}
		if (heap[child] > heap[parent])
		{
			swap(heap[child], heap[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int *a, size_t n)
{
	//建大堆
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		swap(a[0], a[end]);
		AdjustDown(a, end, 0);
		//每次调整之后，堆顶元素都是下标0-end之间最大的
		--end;
	}

}
int main()
{
	int a[] = { 32, 13, 25, 16, 27, 33, 19, 43 };
	int size = sizeof(a) / sizeof(a[0]);
	HeapSort(a, size);
	for (int i = 0; i < size; i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}