堆(heap)

堆(heap)

一、写在前面

   完全二叉树:若设二叉树的深度为h,出第h层外,其他各层(1~h-1)的节点数都达到最大个数,第h层所有的节点都连续集中在最左边。

   堆(heap)是一种数组对象,他可以被视为一颗完全二叉树结构。他的特点是父节点的值大于(小于)两个子节点的值(分别称为大堆和小堆)。他常用于管理算法执行过程中的信息,应用的场景包括堆排序、海量数据处理(TopK)问题和优先级队列等。

声明:本文虽以仿函数实现了大堆和小堆,但以大堆为例讲解。

二、堆得构建及其基本操作

   1、建堆


   如图所示,将数组想象为以下标0为树根(堆顶),左孩子下标等于父亲下标乘二加1,左孩子下标等于父亲下标乘二加2,的完全二叉树。

   方法详解:先利用vector创建一个数组,并将所有数据先放入数组中(push_back())。之后用向下调成算法(_AdjustDown(parent))将较小的数下沉,这样大的数则上升。其中parent为需要向下调整的数的下标,再定义一个child=parent*2+1为parent的左孩子。先判断parent的右孩子存不存在,如果存在,则比较左右孩子的数据谁大,右孩子大则child++。再将大的孩子与parent的数据相比,child大则将其数据与parent的数据互换。最后将child变为parent,child变为child左孩子继续向下调整。

   见下图


   


           2、插入数据


 


   3、删除数据(头删)

   头删即删除堆顶的数据,由于是堆结构,头删必定会破坏其稳定结构,所以需要调节。这里使用的方法是将堆顶数据与数组中最后一个数据交换,然后调用vector的pop_back()方法删除最后一个数据(即原堆顶数据),最后将堆顶的数据向下调整即可。



三、堆得应用

   1、堆排序(heap_sort,升序)

   这里还是利用的向下调整的算法,不过需要修改一点,那就是传的参数需要增加一个调整的范围size。堆排序前提是数组已经是一个堆得结构,然后我们将堆顶的数据与最后一个数据交换,最后一个数据不包含在范围里进行向下调整。


   2、海量数据处理(topK)

   假设有1000个数据需要选出最大的10个数。我们将这1000个数放入数组a中,并选出前10个数,复用之前的代码建立一个大小为10的小堆再将数组a中剩下的数据依次与堆顶数据比较,如果比堆顶数据大,则两数交换,并且堆进行向下调整。这样比较完之后堆中必定留下的是最大的10个数。

下面是海量数据处理的代码:

void AdjustDown(int* heap, size_t parent, int k)
{
	size_t child = parent * 2 + 1;
	while (child < k)
	{
		if (child + 1 < k && heap[child + 1] < heap[child])
		{
			++child;
		}

		if (heap[child] < heap[parent])
		{
			swap(heap[child], heap[parent]);
			parent = child;
			child = child * 2 + 1;
		}
		else
			break;
	}
}

void TopK(int* a, int n, int k)//海量数据处理
{
	assert(n > k);
	int* heap = new int[k];
	for (size_t i = 0; i < k; i++)
	{
		heap[i] = a[i];
	}

	for (int i = (k - 2) / 2; i >= 0; --i)
	{
		AdjustDown(heap, i, k);
	}

	for (int j = k; j < n; j++)
	{
		if (a[j] > heap[0])
		{
			swap(a[j], heap[0]);
			AdjustDown(heap, 0, k);
		}
	}

	for (int m = 0; m < k; m++)
	{
		cout << heap[m] << " ";
	}
	cout << endl;
	delete[] heap;
}

void test()                        //海量数据处理测试
{
	int a[1000];
	for (int i = 0; i < 1000; i++)
	{
		a[i] = i;
	}
	a[100] = 2000;
	a[0] = 1002;
	TopK(a, 1000, 10);
}

四、代码区

#pragma once

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


template<class T>
struct Less                                  //小堆
{
	bool operator()(const T& l, const T& r)
	{
		return l < r;
	}
};

template<class T>
struct Greater                               //大堆
{
	bool operator()(const T& l, const T& r)
	{
		return l > r;
	}
};

template<class T, class Compare>
class Heap
{
public:
	Compare func;
	Heap(T* a, size_t n)//构造堆
	{
		_a.reserve(n);
		for (size_t i = 0; i < n; i++)
		{
			_a.push_back(a[i]);
		}
		for (int i = (_a.size() - 2) / 2; i >= 0; i--)
		{
			_AdjustDown(i);
		}
	}

	const T& Top() const//取堆顶
	{
		return _a[0];
	}

	void Push(const T& x)//插入一个数据
	{
		_a.push_back(x);
		_AdjustUp(_a.size() - 1);
	}

	void Pop()//删除数据
	{
		assert(_a.size() > 0);
		swap(_a[_a.size() - 1], _a[0]);
		_a.pop_back();
		_AdjustDown(0);
	}

	void Heap_Sort(T* a, int n)//堆排序(升序)
	{
		for (size_t i = n - 1; i > 0;--i)
		{
			swap(_a[0], _a[i]);
			_Adjust(0,i);
		}
	}


protected:
	void _Adjust(size_t parent, int size)//堆排序的向下调整
	{
		size_t child = parent * 2 + 1;
		while (child < size)
		{
			if (child + 1 < size && func(_a[child + 1], _a[child]))
			{
				++child;
			}

			if (func(_a[child], _a[parent]))
			{
				swap(_a[child], _a[parent]);
				parent = child;
				child = child * 2 + 1;
			}
			else
				break;
		}
	}

	void _AdjustUp(size_t child)//向上调整
	{
		size_t parent = (child - 1) >> 1;
		while (child > 0)
		{
			if (func(_a[child], _a[parent]))
			{
				swap(_a[child], _a[parent]);
				child = parent;
				parent = (child - 1) >> 1;
			}
			else
				break;
		}
	}

	void _AdjustDown(size_t parent)//向下调整
	{
		size_t child = parent * 2 + 1;
		while (child < _a.size())
		{
			if (child + 1 < _a.size() && func(_a[child + 1], _a[child]))
			{
				++child;
			}

			if (func(_a[child], _a[parent]))
			{
				swap(_a[child], _a[parent]);
				parent = child;
				child = child * 2 + 1;
			}
			else
				break;
		}
	}
protected:
	vector<T> _a;
};

void Test()
{
	int a[10] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 };
	Heap<int, Greater<int>> Hp((int*)a, 10);
	Hp.Push(23);
	Hp.Pop();
	Hp.Heap_Sort((int*)a, 10);
}





评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值