1.什么是堆?
堆是一种数据结构,底层是一种数组对象,它可以被视为一棵完全二叉树结构
最大堆:每个父节点的都大于孩子节点; 最小堆:每个父节点的都小于孩子节点。
2.堆数据结构二叉树存储。
如图所示是个大堆,只能保证父节点比孩子节点大。所以下标为0是整个堆最大的,但无法确定下标为1,2的数据哪个更大
3.堆数据结构和优先级队列的代码实现
思想:从第一个非孩子节点的下标开始向下调整,保证父节点大于子节点否则交换。(大堆),小堆与之相反,所以,这里用到仿函数和模板的模板参数,使得代码能够复用,根据传的参数决定是大堆还是小堆,此处就体现出了c++的优势。若是C的话,这里只能老老实实把相似的代码再写一遍。
#include<iostream>
#include<vector>
#include<cassert>
using namespace std;
template<class T>
struct Grearer
{
bool operator()(const T& left, const T& right)
{
return left > right;
}
};
template<class T>
struct Less
{
bool operator()(const T& left, const T& right)
{
return left < right;
}
};
template<class T,class Compare=Grearer<T>> //模板的模板参数,默认值为大于
class Heap
{
public:
Heap()
{}
Heap(T* a, size_t size) //建堆
{
for (size_t i = 0; i < size; i++) //数组内容拷贝给成员_a
{
_a.push_back(a[i]);
}
for (int i = (size - 2) / 2; i >= 0; i--) //从最后一个非叶子节点向下调整
{
_AjustDown(i);
}
}
void Push(const T& x)
{
_a.push_back(x); //先插到堆的最后一个位置
_AjustUp(_a.size() - 1); //再对最后一个数据向上进行调整
}
void Pop()
{
assert(!_a.empty()); //对空堆进行断言
swap(_a[0], _a[_a.size() - 1]); //交换堆的第一个数据和最后一个
_a.pop_back(); //相当于删除了第一个数据
_AjustDown(0); //对刚放在首位置的数据进行向下调整
}
size_t Size() //堆节点个数
{
return _a.size();
}
const T& Top() //堆的首个数据
{
return _a[0];
}
bool Empty() //堆是否为空
{
return _a.empty();
}
protected:
void _AjustUp(int root) //向上调整
{
size_t child = root;
size_t parient = (child - 1) / 2;
while (child > 0)
{
Compare com;
//if (_a[child] > _a[parient])
if (com(_a[child], _a[parient]))
{
swap(_a[child], _a[parient]);
}
else
{
break;
}
child = parient;
parient = (child - 1) / 2;
}
}
void _AjustDown(int root) //向下调整
{
size_t parient = root;
size_t child = 2 * parient + 1;
while (child<_a.size())
{
Compare com;
if ((child+1<_a.size())&&com(_a[child + 1] , _a[child])) //此处一定要先考虑到右孩子不存在的情况
{
++child;
}
//if (_a[parient] < _a[child])
if (com(_a[child], _a[parient]))
{
swap(_a[parient], _a[child]);
}
parient = child;
child = 2 * parient + 1;
}
}
private:
vector<T>_a;
};
template<class T,class Compare=Grearer<T>>
class PriorityQueue //优先级队列
{
public:
void Push(const T&x)
{
_h.Push(x);
}
void Pop()
{
_h.Pop();
}
size_t Size()
{
return _h.Size();
}
const T& Top()
{
return _h.Top();
}
bool Empty()
{
return _h.Empty();
}
private:
Heap<T,Compare> _h;
};
void test()
{
int a[10] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 };
Heap<int,Less<int>> hp(a, 10);
hp.Push(30);
hp.Pop();
}
void TestPriority() //测试优先级队列
{
PriorityQueue<int> pq;
pq.Push(3);
pq.Push(2);
pq.Push(1);
pq.Push(9);
cout << pq.Top() << endl;
cout << pq.Size() << endl;
pq.Pop();
<h2>}
</h2>
4.堆排序
为什么要使用堆排序呢,因为它的时间复杂度只有O(N*lgN),是一种比较好的排序算法。
以升序为例,基本思想:建好大堆后,把堆的第一个数据的堆的最后一个数据交换,则最后一个位置放置了整个堆中最大的数,此时除了下表为0的数据,剩下的满足大堆,再对剩下的堆进行向下调整(不包括最后一个数据),再把下标为0的数据和堆的倒数第二个数据进行交换,以此类推,最后得到一个有序的数组。
降序反之,建立小堆。算法类似。
升序的代码实现:
#pragma once
#include<iostream>
using namespace std;
void _AjustDown(int* a, size_t size, int root)
{
size_t parient = root;
size_t child = 2 * parient + 1;
while (child<size)
{
if ((child + 1<size) && (a[child + 1]> a[child])) //此处一定要先考虑到右孩子不存在的情况
{
++child;
}
if (a[parient] < a[child])
{
swap(a[parient], a[child]);
}
parient = child;
child = 2 * parient + 1;
}
}
void HeapSort(int* a, size_t size)
{
for (int i = (size - 2) / 2; i >= 0; i--) //建好一个大堆
{
_AjustDown(a, size, i);
}
for (size_t i = 0; i < size; i++)
{
swap(a[0], a[size - 1-i]); //把小标为0的数放在堆的倒数i+1结点处
_AjustDown(a, size - 1 - i, 0); //调整除了最后一个数字的剩下的堆。
}
//return a;
}
void TestHeapSort()
{
int a[10] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 };
HeapSort(a, 10);
}
5.堆的另一种应用——大数据运算
如1亿个数中找出最大的前100个数 (1亿内存放不下)。
类似的题就可以用堆来解决。从1亿数中取出100个数建立一个100数的小堆,从硬盘一个个读取数据,若读出的数比下标为0(堆里最小的数)大,则插入堆,否则丢弃,最后这100个数据的堆保存的就是这1亿个数里面最大的前100个。