一、什么是堆排序？
堆排序就是将待排序元素以一种特定树的结构组合在一起，这种结构被称为堆。
堆又分为大根堆和小根堆，所谓大根堆即为所有的父节点均大于子节点，但兄弟节点之间却没有什么严格的限制，小根堆恰恰相反，是所有的根节点均小于子节点。
所以为了能够实现堆排序，第一个步骤就是将待排序的元素建成堆的形式，其次就是将建好的大根堆（小根堆）与堆的最后一个元素交换，然后再对新的堆进行向下的调整，但是在调整过程中，所有经过交换过的堆底元素不再进行新的调整，直到将倒数第二个元素调整完毕后结束。
所以说堆排序虽说效率较高，但是它的算法步骤却不如其他排序那么明了，需要将它的每一个算法步骤了解清楚后，才能清晰的解析出来。
二、堆排序的算法步骤
在排序家族中，堆排序是一种效率比较高的方法，它的 时间复杂度为O（nlogn），空间复杂度为O（1），它的主要排序步骤为：建堆、交换堆顶、堆底元素再向下调整。
但是在此之前，我们需要先解析出两个分支算法，分别是向下调整和向上调整。
顾名思义，向上（下）调整分别是从堆底（顶）为起始向堆顶（底）进行调整，目的则是严格维护堆的结构不被破坏。
在本文的演示中，我们暂且以大根堆为例。
2.1向下调整
首先，我们以【2，6，3，0，7】为例进行演示。
我们先按照顺序构建堆，如下所示：
然后我们建立两个int类型的变量parent和child，分别指向2和它的子节点，这里子节点的公式为（parent*2+1）。
接下来就是要将parent所指的元素和child所指的元素进行比较，如果parent所指元素小于child所指元素则进行交换，再更新两个变量的位置，如果child所指元素不大于parent所指元素，则跳出循环。
这样，一趟的向下调整就完成了，下面我们用代码实现：
//向下调整
void Modify_down(int parent , int end)
{
int child = parent * 2 + 1;
while (child <= end)
{
if (child + 1 < end && _v[child] < _v[child + 1])
{
child++;
}
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
parent = child;
child = child * 2 + 1;
}
else
break;
}
}2.2向上调整
向上调整和向下调整有所不同，需要先找出其孩子节点中最大的那个，比较之后再进行交换操作，以【2，6，7，0，3】为例。
调整过程中，计算父节点的计算方法为【（child-1）/2】，然后比较兄弟节点，找出最大的那个，如果孩子节点大于父节点，就进行交换，然后更换parent和child的下标位置，如果子节点小于父节点就跳出循环。代码如下：
//向上调整
void Modify_up(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}2.3堆排序
完成两个核心的算法后，我们最后只需将堆排序归纳一下即可。
1、建堆，将堆调整至合法。
//向上调整
void Modify_up(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
//建堆
for (int i = 1; i < _v.size(); i++)
{
Modify_up(i);
}2、交换堆顶和堆底元素，然后再进行向下调整堆，在这里对于堆底的下标我们以变量“end”来控制，当end<=0时，则跳出循环。
//向下调整
void Modify_down(int parent , int end)
{
int child = parent * 2 + 1;
while (child <= end)
{
if (child + 1 < end && _v[child] < _v[child + 1])
{
child++;
}
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
parent = child;
child = child * 2 + 1;
}
else
break;
}
}
int end = _v.size() - 1;
while (end > 0)
{
swap(_v[0], _v[end]);
end--;
Modify_down(0, end);
}三、堆排序完整代码
class heapsort
{
public:
heapsort(vector<int>& v)
:_v(v)
{}
void heap_sort()
{
for (int i = 1; i < _v.size(); i++)
{
Modify_up(i);
}
int end = _v.size() - 1;
while (end > 0)
{
swap(_v[0], _v[end]);
end--;
Modify_down(0, end);
}
}
void Print()
{
for (int i = 0; i < _v.size(); i++)
{
cout << _v[i] << " ";
}
}
protected:
//向上调整
void Modify_up(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
//向下调整
void Modify_down(int parent , int end)
{
int child = parent * 2 + 1;
while (child <= end)
{
if (child + 1 < end && _v[child] < _v[child + 1])
{
child++;
}
if (_v[child] > _v[parent])
{
swap(_v[parent], _v[child]);
parent = child;
child = child * 2 + 1;
}
else
break;
}
}
private:
vector<int> _v;
};四、、堆排序的适用场景
堆排序适用于关键字较多的情况，如：在几亿个关键字中找出前十个最大的数据，我们只需建立小根堆，然后依次循环十次就能得到想要的数据了。
