堆，是一种数据结构，可以看作一棵树的数组对象。看似是一棵树，但其本质是一个数组。
堆总是满足的情况：~堆中的某个节点的值总是不大于或不小于其父亲节点的值；
~堆总是一棵完全二叉树;
大堆：大堆就是每一个孩子节点总是不大于他的父亲节点，但孩子节点的左右没有大小之分。
小堆：小堆就是每一个孩子节点总是不小于他的父亲节点，同样孩子节点左右没有大小之分。如下图所示
实现大小堆其实主要是一个向下调整的过程，如图所示：
具体实现代码如下：
void AdjustDown(int *a, int size, int root)
{
int parent = root;
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 <= 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;
}
}
}
在用堆进行push操作时也需要对堆就行重新调整，即将新加入到数组的最后一个元素进行向上调整，过程如下：
完整代码如下：
void _adjustUp(int n)
{
compare com;
int child = n;
int parent = (n - 1) / 2;
if (_a[child] < _a[parent])
{
return;
}
while (child > 0)
{
if (com(_a[child],_a[parent]))
{
swap(_a[child],_a[parent]);
child = parent;
parent = (parent - 1) / 2;
}
else
{
break;
}
}
}
下面是heap的完整代码：
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:
Heap()
{
}
Heap(const 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);
}
}
void push(T value)
{
_a.push_back(value);
_adjustUp(_a.size()-1);
}
void pop()
{
if (_a.size() == 0)
{
return;
}
//交换第一个和最后一个元素
swap(_a[0], _a[_a.size() - 1]);
//将数组size减一，即原来的第一个元素
_a.pop_back();
//向下调整
_adjustDown(0);
}
protected:
//向下调整
void _adjustDown(int root)
{
compare com;
int parent = root;
int child = root * 2 + 1;
while (child< _a.size())
{
if (child+1<=_a.size() && com(_a[child+1],_a[child]))
{
++child;
}
if (com(_a[child],_a[parent]))
{
swap(_a[child], _a[parent]);
parent=child;
child = child*2+1;
}
else
{
break;
}
}
}
//向上调整
void _adjustUp(int n)
{
compare com;
int child = n;
int parent = (n - 1) / 2;
if (_a[child] < _a[parent])
{
return;
}
while (child > 0)
{
if (com(_a[child],_a[parent]))
{
swap(_a[child],_a[parent]);
child = parent;
parent = (parent - 1) / 2;
}
else
{
break;
}
}
}
protected:
vector<T> _a;
};
堆排序
思想：这里首先将数组元素向下调整成大堆，此时堆顶元素是所有元素最大的，我们将堆顶和数组最后一个元素交换，将此时的堆顶元素进行向下调整，这是数组最后一个元素就是最大的元素，而此时的堆顶是次大的元素，然后我们重复上面交换和调整，这样调整完一遍数组我们就完成了排序，是这样数组变得有序了（这里以大堆为例）。如下图所示：
堆排序代码如下：
void HeapSort(int *a, int size)
{
//建堆
for (int i = (size - 2) / 2; i >= 0; --i)
{
AdjustDown(a, size, i);
}
//排序
size_t end = size - 1;
while (end>0)
{
swap(a[0], a[end]);
AdjustDown(a, end-1 , 0);
end--;
}
}
TopK问题：
思路：首先建立一个k个节点的小堆，此时堆顶元素是这k个元素中最小的元素，然后将下一个入堆的元素与堆顶进行比较，如果小于堆顶则这个元素一定不是最大的倒数k个元素中的一个，如果大于堆顶则将用这个元素代替堆顶元素，这里不是push进来新的元素而是将堆顶元素替换掉，还是k个元素的堆，然后进行调整，然后下一个入堆的元素重复上述的过程，最后留在这个k个元素的堆里面的元素，一定就是最大的倒数k个元素了，如下图所示：
topK问题代码如下：
void topK(int a[], int size, int k)
{
for (int i = (k - 2) / 2; i >= 0; --i)
{
//建个k个元素的小堆
AdjustDownSmall(a, k, i);
}
for (int i = k; i < size; ++i)
{
if (a[0] < a[i])
{
swap(a[0], a[i]);
AdjustDownSmall(a, k, 0);
}
}
}如有错误，欢迎指出。