目录
堆排序
1.算法介绍
堆是一种数据结构，可以把堆看成一棵完全二叉树，这棵完全二叉树满足：任何一个非叶结点的值都不大于（或不小于）其左、右孩子结点的值。若父亲大孩子小，则这样的堆叫作大顶堆；若父亲小孩子大，则这样的堆叫作小顶堆。
根据堆的定义知道，代表堆的这棵完全二叉树的根结点的值是最大（或最小）的，因此将一个无序序列调整为一个堆，就可以找出这个序列的最大（或量小）值，然后将找出的这个值交换到序列的最后（或最前），这样，有序序列关键字增加1个，无序序列中关键字减少1个，对新的无序序列重复这样的操作，就实现了排序。这就是堆排序的思想。
堆排序中最关键的操作是将序列调整为堆。整个排序的过程就是通过不断调整，使得不符合堆定义的完全二叉树变为符合堆定义的完全二叉树。
2. 执行流程
原始序列：49 38 65 97 76 13 27 49
（1）建堆
先将这个序列调整为一个大顶堆。原始序列对应的完全二叉树如图所示。
在这个完全二叉树中，结点 76、13、27、42是叶子结点，它们没有左、右孩子，所以它们满足堆的定义。从97开始，按97、65、38、49的顺序依次调整。
1）调整97。97>49，所以97 和它的孩子49.满足堆的定义，不需要调整，
2）调整 65。65>13,65>27，所以65和它的孩子13、27满是堆的定义，不需要调整。
3）调整38。38<97，38<76，不满足堆定义了，需要调整。在这里，38的两个孩子结点值都比38大，应该和哪个交换呢？显然应该和两者中较大的交换，即和97交换。如果和 76交换，则76<97仍然不满足堆的定义。因此，将38和97 交换。交换后38成了49的根结点，38<42，仍然不满足推定义，需要继续调整，将38 和49交换，结果如图所示。
4）调整 49。49<97，49<65 不满足堆定义，需要调整，找到较大的孩子97，将49 和97交换。交换后49<76 仍不满是堆定义，继续调整，将49与76交换，结果如图所示。
（2）插入结点
需要在插入结点后保持堆的性质，即完全二叉树形态与父大子小的性质（以大顶堆为例），因此需要先将插入的结点x放在最底层的最右边，插入后满足完全二叉树的特点；然后把x依次向上调整到合适位置以满足父大子小的性质。
（3） 删除结点
当删除堆中的一个结点时，原来的位置就会出现一个孔，填充这个孔的方法就是把最底层最右边的叶子的值赋给该孔并下调到合适位置，最后把该叶子删除。
（4） 排序
可以看到，此时已经建立好了一个大顶堆。
对应的序列为：97 76 65 49 49 13 27 38
将堆顶关键字97 和序列最后一个关键字 38交换。第一趟堆排序完成。97到达最终位置。将除97外的序列38 76 65 49 49 13 27 重新调整为大顶堆。现在这个堆只有38 是不满足堆定义的，其他的关键字都满足，所以只需要调整一个38就够了。
调整38，结果如图8-4所示。
现在的序列为：76 49 65 38 49 13 27 97. 将堆顶关键字76和最后一个关键字27交换，第二趟堆排序完成。76到达其最终位置，此时序列为：27 49 65 38 49 13 76 97。
然后对除76 和97 的序列依照上面的方法继续处理，直到树中只剩1个结点时排序完成。
堆排序的执行过程描述（以大顶堆为例）如下：
1）从无序序列所确定的完全二又树的最后一个非叶子结点开始，从右至左，从下至上，对每个结点进行调整，最终将得到一个大顶堆。
对结点的调整方法：将当前结点（假设为a）的值与其孩子结点进行比较，如果存在大于a值的孩子结点，则从中选出最大的一个与a交换。当a来到下一层时重复上述过程，直到a的孩子结点值都小于a的值为止。
2） 将当前无序序列中的第一个关键字，反映在树中是根结点（假设为a）与无序序列中量后一个关键字交换（假设为b）。a进入有序序列，到达最终位置。无序序列中关键学减少1个，有序序列中关键字增加1个。此时只有结点b可能不满足堆的定义，对其进行调整。
3）重复第2）步，直到无序序列中的关键字剩下1个时排序结束。
那么现在用c++来实现一个堆类class heap
其实可以看出 实现堆的构建，最主要就是写出push 然后引出扩容reserve。然后再push过程中加入JustUp函数来实现向上调整，但是实现完后，实现了小根堆。
在实现排序时要对建堆做优化，我们就可以考虑放弃每次插入值的时候都进行一次向上调整，我们可以考虑push完所有值后，来进行堆的向下调整，从堆的最后一个非叶节点开始进行向下调整，这样就能优化时间复杂度。
heap.h 堆类的声明
#pragma once
#include <iostream>
#include <assert.h>
#include <algorithm>
#include <vector>
using namespace std;
//堆排
typedef int HPDataType;
class heap
{
public:
heap()
:_hp(new HPDataType())
{
_hp = nullptr;
_size = _capacity = 0;
}
~heap()
{
delete[] _hp;
_hp = nullptr;
_size = _capacity = 0;
}
//重点
void push(HPDataType x);
HPDataType* c_get_hp();
void Print();
void pop();
bool empty();
int size();
int capacity();
//由push函数引出
void reserve(int n);
//在排序前完成堆的构建，从最后一个非叶节点开始
void JustDown(HPDataType parent, int n);
//向上调整，在push过程中可以实现堆的构建，但是还是最后的向下调整来优化时间复杂度
void JustUp(HPDataType child);
//堆排序
void HeapSort();
private:
HPDataType* _hp;
int _size;
int _capacity;
};
heap.cpp 堆类的定义
#define _CRT_SECURE_NO_WARNINGS 1
#include "heap.h"
HPDataType* heap::c_get_hp()
{
return _hp;
}
void heap::reserve(int n)
{
if (_capacity < n)
{
HPDataType* tmp = new HPDataType[n];
for (int i = 0; i < _size; i++) tmp[i] = _hp[i];
delete[] _hp;
_hp = tmp;
_capacity = n;
}
}
void heap::push(HPDataType x)
{
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);
}
_hp[_size++] = x;
//push的同时要进行向上调整建小堆
//JustUp(_size - 1);
}
void heap::JustUp(HPDataType child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_hp[parent] > _hp[child])
{
std::swap(_hp[parent], _hp[child]);
child = parent;
parent = (child - 1) / 2;
}
else break;
}
}
void heap::JustDown(HPDataType parent, int n)
{
int child = parent * 2 + 1;
int temp = _hp[parent];
while (child < n)
{
if (child<_size - 1 && _hp[child]>_hp[child + 1]) child++;
if (_hp[child] < _hp[parent])
{
std::swap(_hp[child], _hp[parent]);
parent = child;
child = parent * 2 + 1;
}
else break;
}
}
void heap::pop()
{
//删除堆顶元素
//交换最后一个元素跟堆顶元素
std::swap(_hp[0], _hp[_size - 1]);
//向下调整
_size--;
JustDown(0, _size);
}
void heap::HeapSort()
{
//通过向下调整建好的小堆
for (int i = (_size - 1) / 2; i >= 0; i--)
{
JustDown(i, _size);
}
//sort 小堆排降序
for (int i = _size - 1; i > 0; i--)
{
std::swap(_hp[0], _hp[i]);
JustDown(0, i - 1);
}
}
int heap::size()
{
return _size;
}
int heap::capacity()
{
return _capacity;
}
bool heap::empty()
{
return _size == 0;
}
void heap::Print()
{
for (int i = 0; i < _size; i++) cout << _hp[i] << " "; cout << endl;
}
Test.cpp 测试
#define _CRT_SECURE_NO_WARNINGS 1
#include "heap.h"
int main()
{
heap hp;
HPDataType* _hp = hp.c_get_hp();
hp.push(49);
hp.push(38);
hp.push(65);
hp.push(97);
hp.push(76);
hp.push(13);
hp.push(27);
hp.push(49);
hp.Print();
hp.pop();
hp.Print();
hp.HeapSort();
hp.Print();
return 0;
}
3. 算法性能分析
（1） 时间复杂度分析
对于函数JustDown()，显然j走了一条从当前结点到叶子结点的路径，完全二叉树的高度为log(n+1)，即对每个结点调转的时间复杂度为 O(logN)。对于函数 HeapSort()，基本操作总次数应该是两个并列的 for循环中的基本操作次数之和，第一个循环的基本操作次数为 O(logN)×N/2，第二个循环的基本操作次数为 O(logN)×(N-1)，因此整个算法的基本操作次数为 :
O(logN)×N/2 + O(logN)×(N-1) 化简后得其时间复杂度为 O(NlogN)。
（2） 空间复杂度分析
算法所需的辅助存储空间不随待排序序列规模的变化而变化，是个常量，因此空间复杂度为O(1)。
2086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
