堆排序 : 是指利用堆这种数据结构所设计的一种排序算法。堆可以视为一颗完全二叉树。
一、堆的特点
堆可以分为大顶堆和小顶堆。
- 大顶堆 ： 任一结点总是大于其左右孩子结点。所以根节点存储的将是 最大值。
- 小顶堆 ： 任一结点总是小于其左右孩子结点。所以根节点存储的将是 最小值。
堆的拓扑结构是一颗二叉树，而且是 完全二叉树 。根据完全二叉树的特点，通常 堆可以通过一维数组来存储的 。所以当堆中 n 个元素对应数组的 1 - n 序号时，将满足下列特点：
- 父节点 i 的左子节点在位置 2*i；
- 父节点 i 的右子节点在位置 2*i + 1；
- 子节点 i 的父节点在位置 i/2；
如下图所示是小顶堆，10 比它的左右孩子结点更小，并且它的左右孩子又比各自的左右孩子更小。如果10在数组中的序号为1，那么1*2就是它左孩子在数组中的位置，1*2+1就是它右孩子在数组中的位置。
关于堆的其他基本概念的介绍在此不再赘述，可以参考 维基百科 - 堆 以及 堆与堆排序
二、基本操作
堆排序主要涉及以下几种操作，其中 向上/下调整 都是为了在删除和插入新的元素之后，使得堆重新满足堆性。
1. 向下调整
当在根节点位置插入一个新的元素时，很可能就会破坏原有的堆性。如下图，当删除10，并在该位置插入20时，便破坏了堆性。
此时，可以从根节点位置开始向下判断，将当前结点与其左右孩子节点比较， 选出三者中的最小值，然后最小值与当前根结点交换位置。此过程向下递归进行，直到遇到第一个满足堆性的节点时，便可退出。
// 小顶堆
// 向下调整 : 从当前 结点与左/右孩子节点 中选择最小值。
// 形参idx : 需要调整的节点。
void replacedown(int idx)
{
int t; // 最小值的序号
while(idx*2 <= n) // 判断 idx 是否有左孩子
{
// 记录较小值 在数组中的序号
t = (arr[idx] < arr[idx*2] ? idx : 2*idx); //大顶堆，只需要将 < 改为 > 即可
if (idx*2 + 1 <= n) // 是否有右孩子
t = (arr[t] < arr[idx*2 + 1] ? t : 2*idx+1);
if(idx!=t) // 如果idx==t，说明当前结点比左右孩子都小，则说明不需要调整了
{
swap(arr[idx],arr[t]);
idx = t; //更新需要调整的节点序号
}
else
break;
}
}
2. 向上调整
如下图，当在末尾插入一个新的元素时，比如插入 6 ，堆性被破坏。
此时，可以从最后一个节点开始，跟各自的父节点比较，如果不满足小顶堆（或大顶堆）的性质，就交换位置。
因为上图是一个小顶堆，当插入 6 时（作为56的右孩子），首先6跟其父节点56比较，发现56大于6，则交换56与6的位置，此时，6变成了56和70的父节点。然后，6 再跟此时的父节点10进行比较，发现不符合小顶堆性质，则交换位置。 此过程，在第一次遇到满足条件的节点时退出。
// 小顶堆
// 向上调整 : 从当前节点与父节点中选出较小值。
// 形参idx : 需要调整的节点。
void replaceup(int idx)
{
int t;
while(idx > 1) // == 1 代表到了堆顶（根节点），没有父节点了。
{
t = arr[idx] > arr[idx/2] ? idx : idx/2;
if(t != idx) // t != idx 代表当前节点比父节点小，不满足堆性，需要调整。
{
swap(arr[t],arr[idx]);
idx = t;
}
else
break;
}
}3. 建堆
有两种方法。
从堆底逐个插入元素，并进行一次向上调整。
对一个 未堆化 的数组进行建堆时，由于叶子节点没有左右孩子，则必然是满足了堆的性质，只需要对堆中非叶子结点进行调整即可。n/2 为堆中最后一个非叶子节点在数组中的序号，因此，从下往上对堆中的每一颗子树进行调整，只要每一颗子树都满足了堆的性质，那么整个堆就满足了。
void createheap1()
{
int a[] = { 99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 18, 1, 99, 14 };
int len = sizeof(a) / sizeof(a[0]);
n = len;
for (int i = 0; i < len; i++)
{
arr[i + 1] = a[i]; // 将数组 a 中的每个元素逐个插入到数组arr 末尾
replaceup(i+1);
}
}
void createheap2()
{
int a[] = { 99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 18, 1, 99, 14 };
int len = sizeof(a) / sizeof(a[0]);
n = len;
for (int i = 0; i < len; i++)
{
arr[i + 1] = a[i];
}
for (int i = len / 2; i >= 1; i--)
{
replacedown(i);
}
/* 下面的建堆策略也可行，但是相比于replacedown，迭代的次数会增加。
for (int i = len; i >= 1; i--)
{
replaceup(i);
}
*/
}4. 堆排序
如果针对小顶堆进行升序排序，只需要每次将堆顶（根节点）的值保存到另外一个数组（或者直接输出），并将堆底最后一个节点 arr[n]（n为元素个数）的值赋值给根节点，并 n–，然后向下调整replacedown一次，最后把堆中剩余节点中的最小值调整到根节点位置，按照这个方法依次迭代直到n==1。
如果针对小顶堆进行从大到小的排序，只需要每次将根节点与堆底最后一个元素交换位置，并n–，然后再向下调整replacedown一次。
对于大顶堆的排序，方法跟上述类似。
// 堆排序： 从小到大
void heapsort1()
{
while ( n >= 1 )
{
cout << arr[n] ;
arr[1] = arr[n];
n--;
replacedown(1);
}
return ;
}
// 堆排序： 从大到小
void heapsort2()
{
while (n>1)
{
swap(arr[1], arr[n]);
n--;
replacedown(1);
}
return ;
}5. 测试代码
#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
#define MAX 100
int arr[MAX];
int n; //堆中元素的个数
// 向下调整 ：从当前结点 与 左右孩子节点 中选择最小值。
void replacedown(int idx)
{
int t; //需要调整的节点序号
while (idx * 2 <= n) // idx是否有左孩子
{
t = (arr[idx] < arr[idx * 2] ? idx : 2 * idx);
if (idx * 2 + 1 <= n) // 是否有右孩子
t = (arr[t] < arr[idx * 2 + 1] ? t : 2 * idx + 1);
if (idx != t) // 如果idx==t，说明当前结点比左右孩子都小，则说明不需要调整了
{
swap(arr[idx], arr[t]);
idx = t; //更新需要调整的节点序号
}
else
break;
}
}
// 向上调整
void replaceup(int idx)
{
int t;
while (idx > 1)
{
t = arr[idx] > arr[idx / 2] ? idx : idx / 2;
if (t != idx)
{
swap(arr[t], arr[idx]);
idx = t;
}
else
break;
}
}
// 建堆
void createheap()
{
int a[] = { 99, 5, 36, 7, 22, 17, 46, 12, 2, 19, 25, 18, 1, 99, 14 };
int len = sizeof(a) / sizeof(a[0]);
n = len;
for (int i = 0; i < len; i++)
{
arr[i + 1] = a[i];
}
for (int i = len / 2; i >= 1; i--)
{
replacedown(i);
}
}
// 堆排序
void heapsort()
{
while (n>1)
{
swap(arr[1], arr[n]);
n--;
replacedown(1);
}
return ;
}
int main()
{
createheap();
cout << "初始堆 :" << endl;
for_each(begin(arr), end(arr), [](int &val){
if (val!=0)
cout << val << " ";
});
cout << endl;
heapsort();//从大到小排序
cout << "排序后 :" << endl;
for_each(begin(arr), end(arr), [](int &val){
if (val!=0)
cout << val << " ";
});
cout << endl;
return 0;
}结果：
三、STL 堆算法
STL 中关于堆的算法有以下4个（algorithm头文件）通用算法 和 容器适配器 priority_queue。参考 C/C++ 语言参考
make_heap
函数原型：
template <class RandomAccessIterator>
void make_heap (RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
void make_heap (RandomAccessIterator first, RandomAccessIterator last,
Compare comp );其函数原型有两个，一般情况下，我们直接使用的是第一个，第一个构造函数只有两个参数，即容器的起点(begin)与结束点(end)。这个函数原型构造出来的是大顶堆。
当我们需要构造的堆是小顶堆时，我们就可以用到第二个函数原型了。第二个构造函数参数有三个，前两个也是容器的范围，第三个参数则是排序的准则。
push_heap
push_heap函数是基于一个已经是heap的数据来添加元素，重新形成一个heap。这个函数的原型与make_heap函数是一样的。
pop_heap
pop_heap函数则是在一个已经是heap的数据删除掉第一个元素(arr[1])，记住，它总是删除第一个元素！当这个函数删除了第一个元素之后，剩下来的数据元素重新排成heap。
sort_heap
函数原型跟make_heap一样。函数的作用就是将一个heap输出为一个已序的序列，默认情况下是升序排列。
举例：
// range heap example
#include <iostream> // std::cout
#include <algorithm> // std::make_heap, std::pop_heap, std::push_heap, std::sort_heap
#include <vector> // std::vector
int main () {
int myints[] = {10,20,30,5,15};
std::vector<int> v(myints,myints+5);
std::make_heap (v.begin(),v.end()); //std::greater<int>() , 加上此句以创建小顶堆
std::cout << "initial max heap : " << v.front() << '\n';
std::pop_heap (v.begin(),v.end()); //std::greater<int>() , 加上此句以创建小顶堆
v.pop_back();
std::cout << "max heap after pop : " << v.front() << '\n';
v.push_back(99); std::push_heap (v.begin(),v.end()); //std::greater<int>() , 加上此句以创建小顶堆
std::cout << "max heap after push: " << v.front() << '\n';
std::sort_heap (v.begin(),v.end()); //std::greater<int>() , 加上此句按降序排列
std::cout << "final sorted range :";
for (unsigned i=0; i<v.size(); i++)
std::cout << ' ' << v[i];
std::cout << '\n';
return 0;
}priority_queue 优先队列
介绍及使用方法参考 C++参考
1373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
