前言
堆排序在面试中是经常会问到的，特别是应届毕业生找工作时，面试官最喜欢问这个了。当年百度二面的时候，也被这个算法给刷了，因为像我这种不入流的大学，平时所学习的算法只是讲讲基本原理，却没有真正要求动手去实现，因此到真正需要应用的时候，根本就不懂如何去应用。
今天，在回忆、学习完堆排序的相关知识后，希望通过写下本篇文章，将所有的理论知识使用笔者的语言来表达出来，希望能够让大家更容易理解和吸收。
基础知识
我们通常所说的堆是指二叉堆，二叉堆又称完全二叉树或者叫近似完全二叉树。二叉堆又分为最大堆和最小堆。
堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。数组可以根据索引直接获取元素，时间复杂度为O（1），也就是常量，因此对于取值效率极高。
最大堆的特性如下：
- 父结点的键值总是大于或者等于任何一个子节点的键值
- 每个结点的左子树和右子树都是一个最大堆
最小堆的特性如下：
- 父结点的键值总是小于或者等于任何一个子节点的键值
- 每个结点的左子树和右子树都是一个最小堆
算法思想
最大堆的算法思想是：
- 先将初始的R[0…n-1]建立成最大堆，此时是无序堆，而堆顶是最大元素
- 再将堆顶R[0]和无序区的最后一个记录R[n-1]交换，由此得到新的无序区R[0…n-2]和有序区R[n-1]，且满足R[0…n-2].keys ≤ R[n-1].key
- 由于交换后，前R[0…n-2]可能不满足最大堆的性质，因此再调整前R[0…n-2]为最大堆，直到只有R[0]最后一个元素才调整完成。
最大堆排序完成后，其实是升序序列，每次调整堆都是要得到最大的一个元素，然后与当前堆的最后一个元素交换，因此最后所得到的序列是升序序列。
最小堆的算法思想是：
- 先将初始的R[0…n-1]建立成最小堆，此时是无序堆，而堆顶元素是最小的元素
- 再将堆顶R[0]与无序区的最后一个R[n-1]交换，由此得到新的无序堆R[0…n-2]和有序堆R[n-1]，且满足R[0…n-2].keys >= R[n-1].key
- 由于交换后，前R[0…n-2]可能不满足最小堆的性质，因此再调整前R[0…n-2]为最小堆，直到只有R[0]最后一个元素才调整完成
最小堆排序完成后，其实是降序序列，每次调整堆都是要得到最小的一个元素，然后与当前无序堆的最后一个元素交换，所以所得到的序列是降序的。
提示：堆排序的过程，其实就是不断地扩大有序区，然后不断地缩小无序区，直到只有有序区的过程。
排序过程分析
因为算法比较抽象，这里直接通过举个小例子来说明堆排序的过程是如何的。下面我们用这个无序序列采用最大堆的进行堆排序，所得到的序列就是升序序列（ASC）。
无序序列：89,-7,999,-89,7,0,-888,7,-7
第一步：初始化建成最大堆：
第二步：将堆顶最大元素999与无序区的最后一个元素交换，使999成为有序区。交换后，-7成为堆顶，由于-7并不是无序区中最大的元素，因此需要调整无序区，使无序区中最大值89成为堆顶，所以-7与89交换。交换后导致89的右子树不满足最大堆的性质，因此要对右子树调整成最大堆，所以-7要与0交换，如下图：
从图中看到，当-7成89交换后，堆顶是最大元素了，但是-7的左孩子是0，右孩子是-888，由于-7<0，导致-7这个结点不满足堆的性质，因此需要调整它。所以，0与-7交换。
然后不断重复着第二步的过程，直到全部成为有序区。
最后：所得到的是升序序列
时间复杂度
堆排序的时间，主要由建立初始堆和反复调整堆这两部分的时间开销构成.由于堆排序是不稳定的，它得扭到的时间复杂度会根据实际情况较大，因此只能取平均时间复杂度。
平均时间复杂度为：O( N * log2(N) )
堆排序耗时的操作有：初始堆 + 反复调整堆，时间复杂度如下：
- 初始建堆：每个父节点会和左右子节点进行最多2次比较和1次交换，所以复杂度跟父节点个数有关。根据2x <= n（x为n个元素可以折半的次数，也就是父节点个数），得出x = log2n。即O ( log2n )
- 反复调整堆：由于初始化堆过程中，会记录数组比较结果，所以堆排序对原序列的数组顺序并不敏感，最好情况和最坏情况差不多。需要抽取 n-1 次堆顶元素，每次取堆顶元素都需要重建堆（O(重建堆) < O(初始堆)）。所以小于 O(n-1) * O(log2n)
使用建议：
由于初始化堆需要比较的次数较多，因此，堆排序比较适合于数据量非常大的场合（百万数据或更多）。由于高效的快速排序是基于递归实现的，所以在数据量非常大时会发生堆栈溢出错误。
C语言实现
基于最大堆实现升序排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
// 初始化堆
void
initHeap
(
int
a
[
]
,
int
len
)
{
// 从完全二叉树最后一个非子节点开始
// 在数组中第一个元素的索引是0
// 第n个元素的左孩子为2n+1，右孩子为2n+2，
// 最后一个非子节点位置在(n - 1) / 2
for
(
int
i
=
(
len
-
1
)
/
2
;
i
>=
0
;
--
i
)
{
adjustMaxHeap
(
a
,
len
,
i
)
;
}
}
void
adjustMaxHeap
(
int
a
[
]
,
int
len
,
int
parentNodeIndex
)
{
// 若只有一个元素，那么只能是堆顶元素，也没有必要再排序了
if
(
len
<=
1
)
{
return
;
}
// 记录比父节点大的左孩子或者右孩子的索引
int
targetIndex
=
-
1
;
// 获取左、右孩子的索引
int
leftChildIndex
=
2
*
parentNodeIndex
+
1
;
int
rightChildIndex
=
2
*
parentNodeIndex
+
2
;
// 没有左孩子
if
(
leftChildIndex
>=
len
)
{
return
;
}
// 有左孩子，但是没有右孩子
if
(
rightChildIndex
>=
len
)
{
targetIndex
=
leftChildIndex
;
}
// 有左孩子和右孩子
else
{
// 取左、右孩子两者中最大的一个
targetIndex
=
a
[
leftChildIndex
]
>
a
[
rightChildIndex
]
?
leftChildIndex
: rightChildIndex
;
}
// 只有孩子比父节点的值还要大，才需要交换
if
(
a
[
targetIndex
]
>
a
[
parentNodeIndex
]
)
{
int
temp
=
a
[
targetIndex
]
;
a
[
targetIndex
]
=
a
[
parentNodeIndex
]
;
a
[
parentNodeIndex
]
=
temp
;
// 交换完成后，有可能会导致a[targetIndex]结点所形成的子树不满足堆的条件，
// 若不满足堆的条件，则调整之使之也成为堆
adjustMaxHeap
(
a
,
len
,
targetIndex
)
;
}
}
void
heapSort
(
int
a
[
]
,
int
len
)
{
if
(
len
<=
1
)
{
return
;
}
// 初始堆成无序最大堆
initHeap
(
a
,
len
)
;
for
(
int
i
=
len
-
1
;
i
>
0
;
--
i
)
{
// 将当前堆顶元素与最后一个元素交换，保证这一趟所查找到的堆顶元素与最后一个元素交换
// 注意：这里所说的最后不是a[len - 1]，而是每一趟的范围中最后一个元素
// 为什么要加上>0判断？每次不是说堆顶一定是最大值吗？没错，每一趟调整后，堆顶是最大值的
// 但是，由于len的范围不断地缩小，导致某些特殊的序列出现异常
// 比如说，5, 3, 8, 6, 4序列，当调整i=1时，已经调整为3,4,5,6,8序列，已经有序了
// 但是导致了a[i]与a[0]交换，由于变成了4,3,5,6,8反而变成无序了!
if
(
a
[
0
]
>
a
[
i
]
)
{
int
temp
=
a
[
0
]
;
a
[
0
]
=
a
[
i
]
;
a
[
i
]
=
temp
;
}
// 范围变成为：
// 0...len-1
// 0...len-1-1
// 0...1 // 结束
// 其中，0是堆顶，每次都是找出在指定的范围内比堆顶还大的元素，然后与堆顶元素交换
adjustMaxHeap
(
a
,
i
-
1
,
0
)
;
}
}
|
基于最小堆实现降序排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
// 初始化堆
void
initHeap
(
int
a
[
]
,
int
len
)
{
// 从完全二叉树最后一个非子节点开始
// 在数组中第一个元素的索引是0
// 第n个元素的左孩子为2n+1，右孩子为2n+2，
// 最后一个非子节点位置在(n - 1) / 2
for
(
int
i
=
(
len
-
1
)
/
2
;
i
>=
0
;
--
i
)
{
adjustMinHeap
(
a
,
len
,
i
)
;
}
}
void
adjustMinHeap
(
int
a
[
]
,
int
len
,
int
parentNodeIndex
)
{
// 若只有一个元素，那么只能是堆顶元素，也没有必要再排序了
if
(
len
<=
1
)
{
return
;
}
// 记录比父节点大的左孩子或者右孩子的索引
int
targetIndex
=
-
1
;
// 获取左、右孩子的索引
int
leftChildIndex
=
2
*
parentNodeIndex
+
1
;
int
rightChildIndex
=
2
*
parentNodeIndex
+
2
;
// 没有左孩子
if
(
leftChildIndex
>=
len
)
{
return
;
}
// 有左孩子，但是没有右孩子
if
(
rightChildIndex
>=
len
)
{
targetIndex
=
leftChildIndex
;
}
// 有左孩子和右孩子
else
{
// 取左、右孩子两者中最上的一个
targetIndex
=
a
[
leftChildIndex
]
<
a
[
rightChildIndex
]
?
leftChildIndex
: rightChildIndex
;
}
// 只有孩子比父节点的值还要小，才需要交换
if
(
a
[
targetIndex
]
<
a
[
parentNodeIndex
]
)
{
int
temp
=
a
[
targetIndex
]
;
a
[
targetIndex
]
=
a
[
parentNodeIndex
]
;
a
[
parentNodeIndex
]
=
temp
;
// 交换完成后，有可能会导致a[targetIndex]结点所形成的子树不满足堆的条件，
// 若不满足堆的条件，则调整之使之也成为堆
adjustMinHeap
(
a
,
len
,
targetIndex
)
;
}
}
void
heapSort
(
int
a
[
]
,
int
len
)
{
if
(
len
<=
1
)
{
return
;
}
// 初始堆成无序最小堆
initHeap
(
a
,
len
)
;
for
(
int
i
=
len
-
1
;
i
>
0
;
--
i
)
{
// 将当前堆顶元素与最后一个元素交换，保证这一趟所查找到的堆顶元素与最后一个元素交换
// 注意：这里所说的最后不是a[len - 1]，而是每一趟的范围中最后一个元素
// 为什么要加上>0判断？每次不是说堆顶一定是最小值吗？没错，每一趟调整后，堆顶是最小值的
// 但是，由于len的范围不断地缩小，导致某些特殊的序列出现异常
// 比如说，5, 3, 8, 6, 4序列，当调整i=1时，已经调整为3,4,5,6,8序列，已经有序了
// 但是导致了a[i]与a[0]交换，由于变成了4,3,5,6,8反而变成无序了!
if
(
a
[
0
]
<
a
[
i
]
)
{
int
temp
=
a
[
0
]
;
a
[
0
]
=
a
[
i
]
;
a
[
i
]
=
temp
;
}
// 范围变成为：
// 0...len-1
// 0...len-1-1
// 0...1 // 结束
// 其中，0是堆顶，每次都是找出在指定的范围内比堆顶还小的元素，然后与堆顶元素交换
adjustMinHeap
(
a
,
i
-
1
,
0
)
;
}
}
|
C语言版测试
大家可以测试一下：
|
1
2
3
4
5
6
7
8
9
|
// int a[] = {5, 3, 8, 6, 4};
int
a
[
]
=
{
89
,
-
7
,
999
,
-
89
,
7
,
0
,
-
888
,
7
,
-
7
}
;
heapSort
(
a
,
sizeof
(
a
)
/
sizeof
(
int
)
)
;
for
(
int
i
=
0
;
i
<
sizeof
(
a
)
/
sizeof
(
int
)
;
++
i
)
{
NSLog
(
@"%d"
,
a
[
i
]
)
;
}
|
Swift版实现
基于最大堆实现升序排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
func
initHeap
(
inout
a
:
[
Int
]
)
{
for
var
i
=
(
a
.
count
-
1
)
/
2
;
i
>=
0
;
--
i
{
adjustMaxHeap
(
&
a
,
len
: a
.
count
,
parentNodeIndex
: i
)
}
}
func
adjustMaxHeap
(
inout
a
:
[
Int
]
,
len
: Int
,
parentNodeIndex
: Int
)
{
// 如果len <= 0，说明已经无序区已经缩小到0
guard
len
>
1
else
{
return
}
// 父结点的左、右孩子的索引
let
leftChildIndex
=
2
*
parentNodeIndex
+
1
// 如果连左孩子都没有， 一定没有右孩子，说明已经不用再往下了
guard
leftChildIndex
<
len
else
{
return
}
let
rightChildIndex
=
2
*
parentNodeIndex
+
2
// 用于记录需要与父结点交换的孩子的索引
var
targetIndex
=
-
1
// 若没有右孩子，但有左孩子，只能选择左孩子
if
rightChildIndex
>
len
{
targetIndex
=
leftChildIndex
}
else
{
// 左、右孩子都有，则需要找出最大的一个
targetIndex
=
a
[
leftChildIndex
]
>
a
[
rightChildIndex
]
?
leftChildIndex
: rightChildIndex
}
// 只有孩子比父结点还要大，再需要交换
if
a
[
targetIndex
]
>
a
[
parentNodeIndex
]
{
let
temp
=
a
[
targetIndex
]
a
[
targetIndex
]
=
a
[
parentNodeIndex
]
a
[
parentNodeIndex
]
=
temp
// 由于交换后，可能会破坏掉新的子树堆的性质，因此需要调整以a[targetIndex]为父结点的子树，使之满足堆的性质
adjustMaxHeap
(
&
a
,
len
: len
,
parentNodeIndex
: targetIndex
)
}
}
func
maxHeapSort
(
inout
a
:
[
Int
]
)
{
guard
a
.
count
>
1
else
{
return
}
initHeap
(
&
a
)
for
var
i
=
a
.
count
-
1
;
i
>
0
;
--
i
{
// 每一趟都将堆顶交换到指定范围内的最后一个位置
if
a
[
0
]
>
a
[
i
]
{
let
temp
=
a
[
0
]
a
[
0
]
=
a
[
i
]
a
[
i
]
=
temp
}
print
(
a
)
print
(
i
-
1
)
// 有序区长度+1，而无序区长度-1，继续缩小无序区，所以i-1
// 堆顶永远是在0号位置，所以父结点调整从堆顶开始就可以了
adjustMaxHeap
(
&
a
,
len
: i
-
1
,
parentNodeIndex
:
0
)
print
(
a
)
}
}
|
基于最小堆降序排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
func
initHeap
(
inout
a
:
[
Int
]
)
{
for
var
i
=
(
a
.
count
-
1
)
/
2
;
i
>=
0
;
--
i
{
adjustMinHeap
(
&
a
,
len
: a
.
count
,
parentNodeIndex
: i
)
}
}
func
adjustMinHeap
(
inout
a
:
[
Int
]
,
len
: Int
,
parentNodeIndex
: Int
)
{
// 如果len <= 0，说明已经无序区已经缩小到0
guard
len
>
1
else
{
return
}
// 父结点的左、右孩子的索引
let
leftChildIndex
=
2
*
parentNodeIndex
+
1
// 如果连左孩子都没有， 一定没有右孩子，说明已经不用再往下了
guard
leftChildIndex
<
len
else
{
return
}
let
rightChildIndex
=
2
*
parentNodeIndex
+
2
// 用于记录需要与父结点交换的孩子的索引
var
targetIndex
=
-
1
// 若没有右孩子，但有左孩子，只能选择左孩子
if
rightChildIndex
>
len
{
targetIndex
=
leftChildIndex
}
else
{
// 左、右孩子都有，则需要找出最大的一个
targetIndex
=
a
[
leftChildIndex
]
<
a
[
rightChildIndex
]
?
leftChildIndex
: rightChildIndex
}
// 只有孩子比父结点还要大，再需要交换
if
a
[
targetIndex
]
<
a
[
parentNodeIndex
]
{
let
temp
=
a
[
targetIndex
]
a
[
targetIndex
]
=
a
[
parentNodeIndex
]
a
[
parentNodeIndex
]
=
temp
// 由于交换后，可能会破坏掉新的子树堆的性质，因此需要调整以a[targetIndex]为父结点的子树，使之满足堆的性质
adjustMinHeap
(
&
a
,
len
: len
,
parentNodeIndex
: targetIndex
)
}
}
func
minHeapSort
(
inout
a
:
[
Int
]
)
{
guard
a
.
count
>
1
else
{
return
}
initHeap
(
&
a
)
for
var
i
=
a
.
count
-
1
;
i
>
0
;
--
i
{
// 每一趟都将堆顶交换到指定范围内的最后一个位置
if
a
[
0
]
<
a
[
i
]
{
let
temp
=
a
[
0
]
a
[
0
]
=
a
[
i
]
a
[
i
]
=
temp
}
else
{
return
// 可以直接退出了，因为已经全部有序了
}
// 有序区长度+1，而无序区长度-1，继续缩小无序区，所以i-1
// 堆顶永远是在0号位置，所以父结点调整从堆顶开始就可以了
adjustMinHeap
(
&
a
,
len
: i
-
1
,
parentNodeIndex
:
0
)
}
}
|
测试：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
var
arr
=
[
5
,
3
,
8
,
6
,
4
]
//var arr = [89,-7,999,-89,7,0,-888,7,-7]
maxHeapSort
(
&
arr
)
print
(
arr
)
// 打印日志如下：
[
4
,
6
,
5
,
3
,
8
]
3
[
6
,
4
,
5
,
3
,
8
]
[
3
,
4
,
5
,
6
,
8
]
2
[
5
,
4
,
3
,
6
,
8
]
[
3
,
4
,
5
,
6
,
8
]
1
[
3
,
4
,
5
,
6
,
8
]
[
3
,
4
,
5
,
6
,
8
]
0
[
3
,
4
,
5
,
6
,
8
]
[
3
,
4
,
5
,
6
,
8
]
|
最后
花了将近一天半的时间来整理这篇文章，同时深入地理解这个算法。这个过程中，查了很多篇博客讲解堆排序的，但是都是很难去理解，而且所提供的代码都是有一定问题的。经过这么一折腾，终于把堆排序给理明白了。如果大家在学习时遇到问题，再联系笔者吧！
