堆是一种数据结构,就是每个节点根据某种规则排序, 从根节点往下都符合某种规律,
根节点的值比所有节点的值都大, 称为最大堆;
根节点的值比所有节点的值都小, 称为最小堆;
为了统一操作, 我们规定:
1. 堆存储在 顺序数组中, 下标从 1 开始,
2. 以大根堆为例
3. 元素个数为 n 或者 len
堆排序 step:
一)建树部分
1. 找到一个树的最后一个非叶节点, 计算公式为 [n/2] 向下取整, 然后遍历树的每个非叶节点,使其符合堆的规则
红圈为最后一个 非叶 子节点
void make_heap(int *a, int len)
{
for(int i = len/2; i >= 1; --i) //遍历每个 非叶子节点
adjust_heap(a, i, len);//不用考虑那么多, 用面向对象的思想去考虑,
} //这个函数的作用就是用来使 当前节点的子树 符合 堆的规律
2. 要使某节点的当前节点的字数符合 堆规律,需要以下操作:
void adjust_heap(int* a, int node, int len)
{
int left = 2 * node;
int right = 2 * node + 1;
int max = node;
if( left <= len && a[left] > a[max]) //left <= len 防止节点不存在
max = left;
if( right <= len && a[right] > a[max]) //a[right] > a[max] 判断是不是根节点最大(因为你每个子树都要符合大根堆的性质啊)
max = right;
if(max != node)//确实最大值不是 父节点
{
swap( a[max], a[node]); //交换节点
adjust_heap(a, max, len);//从当前节点开始,调整下面的堆
}//关于这里递归的解释请看下面
}
90 和 7交换后, 发现 7 不能管住 原来90的两个儿子, 那怎么办呢??那就继续调用adjust() 让他符合
所以需要递归。
到此为止
这个整个树都符合 堆的规律了, 最大堆就已经建造好了。
二)排序部分
此时 [1, len] 为一个堆 , 现在我们需要把 整个堆中的元素 排 升序, 该如何呢 ???
1) 将堆的顶部,与最后一个元素交换。
此时 最后一个元素已经有序, 且是整个个序列中的最大值, 这符合特性
2) 剩下元素 [1, len-1] 所组成的树已经不是 堆了。(因为此时顶部的元素是最小的)。
所以, 要将剩下的元素通过 adjust函数调整成 堆。
然后,继续将剩余元素中的最后一个元素 与 新堆的顶部交换 。。。。。。重复 1) 2)
代码如下:
for(int i = len; i >= 1; --i)//2. 堆排序
{
swap(a[1], a[i]);
adjust_heap(a, 1, i - 1);//剩余堆的范围变成了 [1, len-1]
} //由上一步的交换可能破坏堆的性质, 故要对剩余的堆进行调整
完整代码如下:
#include <iostream>
using namespace std;
//为了统一操作, 堆存储在 顺序数组中, 下标从 1 开始, 以大根堆为例
void adjust_heap(int* a, int father, int len)//判断是不是符合大根堆
{
int left = 2 * father;
int right = 2 * father + 1;
int max = father;
if( left <= len && a[left] > a[max])//left <= len 防止节点不存在
max = left;
if( right <= len && a[right] > a[max])//a[right] > a[max] 判断是不是根节点最大(因为你每个子树都要符合大根堆的性质啊)
max = right;
if(max != father)
{
swap( a[max], a[father]);//交换节点
adjust_heap(a, max, len);//从当交换后前节点开始, 调整下面的堆
}//这里的 max 是当前 father 的某一个儿子, 而不是 father 自身, 因为交换后 father 本来就是有序的.
}
void heap_sort(int* a, int len)
{
for(int i = len / 2; i >= 1; --i) //1.创建堆make_heap, 从最后一个非叶子节点开始
adjust_heap(a, i, len);
for(int i = len; i >= 1; --i)//2. 堆排序, 此时 [1, len] 为一个堆
{
swap(a[1], a[i]); //将 堆顶元素(数组首位) 与 堆末元素(数组末位) 互换.
adjust_heap(a, 1, i - 1); // 此时堆末元素已经有序(存的是最大值),
}// 剩余堆的范围变成了 [1, len-1], 但由于上一步的交换可能破坏堆的性质, 故要进行调整
}
int main()
{
int a[11] = {-999, 7, 3, 4, 5, 2, 0, -1, 10, 0, 9};
int len = sizeof(a) / sizeof(int);
//cout << len << endl;
for(int i = 1; i <= len; ++i)
cout << a[i] << ' ';
cout << endl;
heap_sort(a, len);//len = 11, 但是约定 a[0] 不存值, 有意义的值从 a[1] 开始
for(int i = 1; i <= len; ++i)
cout << a[i] << ' ';
cout << endl;
return 0;
}
然而堆排序中的几个函数,还是可以通过优化来提升 时间复杂度的。比如 adjust()函数的优化
如果在用 adjust在调整最大堆时, 交换需要以下操作:
temp = a[node];
a[node] = a[max];
a[max] = temp;
需要操作三次,100000次 的交换需要操作 300000次。太过于耗时。所以我们可以做类似于插入排序的优化。
if( 节点的某一个儿子 > 节点本身 )
用 temp 把儿子存起来, 并把节点赋值给儿子;
用temp上浮一层到节点的位置, 继续执行判断, 这样一层层不停的上浮。直到不符合条件
if( temp < 同一层的兄弟节点 || temp < 父亲节点)
把 temp 赋值给当前层的元素;
这样省去了每次的交换, 100000的操作只需要操作100000次。大大提高了效率