堆的应用（优先级队列、海量数据处理、堆排序）

一、优先级队列

1、基本思路

其实可以使用队列来实现，但是不可避免的是Push()和Pop()操作，至少有一个的时间复杂度为O(N),另一个的时间复杂度为O(1),而使用对可以做到插入时时间复杂度为O(lgN),，删除时时间复杂度为O(1)

2、具体实现

是通过适配器模式来实现的，通过对Heap的封装

（1）堆的实现

具体实现前面已有博客讲解过，这里就不具体讲解了

（2）优先级队列的实现

template<class T,template<class> class Compare=Less>
class PriorityQueue
{
public:
void Push(const T& x)
{
_hp.Push(x);
}

void Pop()
{
_hp.Pop();
}

T& Top()
{
return Top();
}

size_t Size()
{
return _hp.Size();
}

bool Empty()
{
return _hp.Empty();
}

protected:
Heap<T, Compare> _hp;
};

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

1、基本思路

（1）方法一：生成一个大小为100的数组，燃油遍历一边这100w个数

（2）方法二：将这100w个数放入到内存中去，然后排序，找去前100个数

（3）方法三：前两者的时间复杂度都太高，效率太低，所以不采用以上两种方法，使用堆来实现

2.具体思路

到底是使用 大根堆来实现还是用小根堆来实现呢？

大根堆和小根堆可以保证第一个数是最小或最小的。如果选择大根堆的话，那么就只能保证这100个选出来的数中第一个数是最大的，因为次大的数有可能进不来，（那么为什么不和最小的叶子节点做比较，因为最小的叶子节点并不能保证它是已经选择出来的100个数中最小的）

所以选择小根堆，比选出来的100个数最小的大的数便会进入堆中，并且会下调，就可以始终保证根节点的值是最小的

三、海量数据处理

1.题目

2015年春节期间，A公司的支付软件某宝和T公司某信红包大乱战。春节后高峰以后，公司Leader要求后台的攻城狮对后台的海量数据进行分析。先要求分析出各地区发红包金额最多的前100用户。现在知道人数最多的s地区大约有1000w用户。要求写一个算法实现。

2、基本思路

其实和应用二的基本思路相同。通过对数组下标1到100之间的元素建成一个堆，然后后面的元素不断和根节点来比较，从而决定是进堆还是不进堆

3.具体实现

代码如下：

void AdjustDown(int* pKArray, size_t root, size_t size)
{
size_t parent = root;
size_t child = root * 2 - 1;
while (child < size)
{
if (child + 1 < size&&pKArray[child + 1] < pKArray[child])
{
++child;
}
if (pKArray[parent] > pKArray[child])
{
std::swap(pKArray[parent], pKArray[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}

void GetTopK(const vector<int>& moneys, int n, int k)
{
assert(n > k);
int* topKArray = new int[k];
for (size_t i = 0; i < k; ++i)
{
topKArray[i] = moneys[i];
}
//建小根堆
for (int i = (k - 2) / 2; i >= 0; --i)
{
AdjustDown(topKArray, 0, k);
}
for (size_t i = 0; i < k; ++i)
{
cout << topKArray[i] << " ";
}
cout << endl;
delete[] topKArray;
}

void GreatRedPacket(vector<int>& moneys)
{
srand(time(0));
moneys.reserve(N);
for (int i = 0; i < N; ++i)
{
moneys.push_back(rand() % 1000);
}

for (int j = N - K; j < N; ++j)
{
moneys[j] = rand()%N;
}

}

测试用例：

void Test()
{
vector<int> arr;
GreatRedPacket(arr);
GetTopK(arr,N,K);
cout << endl;
}

三、堆排序

1.基本思路：

堆排序其实是选择排序的一种，只不过每次都要重新建堆

2、集体思路

以升序做为例子来讲：

那么是建大堆还是小堆呢？

（1）建小堆的话，确实下标最小的元素的确是最小的，但是每次选出最小的之后，剩下的都要从新再调整为一个小堆

（2）建大堆的话，根节点是最大的值，每次和最后一个叶子节点的值做交换，接下来将交换后的根节点向下调整，这样就不用从新建堆了

3.具体实现

实现升序

代码如下：

void AdjustDown(int* a, size_t size, size_t root)
{
size_t parent = root;
size_t child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size&&a[child + 1] > a[child])
{
++child;
}
if (a[child]>a[parent])
{
std::swap(a[child], a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}

void HeapSort(int* a, size_t size)
{
//见堆
for (int i = (size-2) / 2; i >= 0; --i)
{
AdjustDown(a, size, i);
}
for (size_t i = 0; i < size; ++i)
{
std::swap(a[0], a[size - i - 1]);//最后一个数的下标
AdjustDown(a, size - i - 1, 0);//个数
}
}

测试用例：

void Test()
{
int a[] = { 10, 11, 12, 14, 12, 1, 2, 3, 4, 15, 19 };
int len = sizeof(a) / sizeof(a[0]);
HeapSort(a, len);
for (size_t i = 0; i < len; ++i)
{
cout << a[i] << " ";
}
}