堆排序是颇有难度的算法。搞懂以后就以为,"还行吧"。html
先讲个故事: 周日学校有开个实习的招聘会,没有拿到大公司offer的我,固然约上舍友走起啦。第一家,有人在面试了,那我就在旁边听下,只记得,"你会快排吗? 堆排序呢? 如今你能写出堆排序的算法??" 同为大三的面试者: "......"。python
第二家,看了下,有招后台,好极了。面试
招python开发的吗? 用啥框架?? 我用django的。很好,公司也有用django。我内心那个高兴啊。后来,聊着聊着,不对劲。面试官话里透露着一股ds的气息……我怀疑他仍是学生……算法
他还说了公司的老板,居然是我学校的老师,卧擦。我学校的老师居然“兼职”去当老板了,心理多少不爽啊!! 毕竟,平时上课,教得太水了,上课浪费我时间,还总是点名。(固然少部分仍是很好的)。后来换位思考,也就想通了。其实我也想当老板……谁都这样吧。django
-------------------------华丽分割线-------------------------编程
堆分为最大堆和最小堆,其实就是彻底二叉树。最大堆要求节点的元素都要不小于其孩子,最小堆要求节点元素都不大于其左右孩子,二者对左右孩子的大小关系不作任何要求,其实很好理解。有了上面的定义,咱们能够得知,处于最大堆的根节点的元素必定是这个堆中的最大值。数组
其实咱们的堆排序算法就是抓住了堆的这一特色,每次都取堆顶的元素,将其放在序列最后面,而后将剩余的元素从新调整为最大堆,依次类推,最终获得排序的序列。框架
下图来张教材的图,是整个堆排序的过程: 整个过程的核心就是先初始化大顶堆,将最大数(堆顶)的放到堆的最后一个, 堆长度-1, 继续调整成大顶堆,直至有序序列为len(array_list)-1.ide
堆排序前42是在42后面,排序后42在42前面,所以堆排序是不稳定的。ui
给定一个列表array=[16,7,3,20,17,8],对其进行堆排序。
首先根据该数组元素构建一个彻底二叉树,获得
20和16交换后致使16不知足堆的性质,所以需从新调整
这样就获得了初始堆。
第二步: 堆顶元素R[1]与最后一个元素R[n]交换,交换后堆长度减一
第三步: 从新调整堆。此时3位于堆顶不满堆的性质,则需调整继续调整(从顶点开始往下调整)
重复上面的步骤:
注意了,如今你应该了解堆排序的思想了,给你一串列表,你也能写出&说出堆排序的过程。
在写算法的过程当中,刚开始我是很懵比。后来终于看懂了。请特别特别注意: 初始化大顶堆时 是从最后一个有子节点开始往上调整最大堆。而堆顶元素(最大数)与堆最后一个数交换后,需再次调整成大顶堆,此时是从上往下调整的。
不论是初始大顶堆的从下往上调整,仍是堆顶堆尾元素交换,每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换,交换以后都可能形成被交换的孩子节点不知足堆的性质,所以每次交换以后要从新对被交换的孩子节点进行调整。我在算法中是用一个while循环来解决的
首先,我先初始化大顶堆:
1 def sift_down(array, start, end): 2 """
3 调整成大顶堆,初始堆时,从下往上;交换堆顶与堆尾后,从上往下调整 4 :param array: 列表的引用 5 :param start: 父结点 6 :param end: 结束的下标 7 :return: 无 8 """
9 # 当列表第一个是如下标0开始,结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2;
10 # 若下标以1开始,左孩子则为2*i,右孩子则为2*i+1
11 left_child = 2*start + 1 # 左孩子的结点下标
12 # 当结点的右孩子存在,且大于结点的左孩子时
13 if left_child+1 <= end and array[left_child+1] > array[left_child]: 14 left_child += 1
15 if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时,则交换
16 temp = array[left_child] 17 array[left_child] = array[start] 18 array[start] = temp 19
20 print(">>", array) 21
22
23 def heap_sort(array): # 堆排序
24 # 先初始化大顶堆
25 first = len(array)//2 -1 # 最后一个有孩子的节点(//表示取整的意思)
26 # 第一个结点的下标为0,不少博客&课本教材是从下标1开始,无所谓吧,你随意
27 for i in range(first, -1, -1): # 从最后一个有孩子的节点开始往上调整
28 print(array[i]) 29 sift_down(array, i, len(array)-1) # 初始化大顶堆
30
31 print("初始化大顶堆结果:", array) 32
33 if __name__ == "__main__": 34 array = [16, 7, 3, 20, 17, 8] 35 print(array) 36 heap_sort(array) 37 print(array)
看下运行结果,发现有问题:
[16, 7, 3, 20, 17, 8] 3 >> [16, 7, 8, 20, 17, 3] 7 >> [16, 20, 8, 7, 17, 3] 16 >> [20, 16, 8, 7, 17, 3] 初始化大顶堆结果: [20, 16, 8, 7, 17, 3] [20, 16, 8, 7, 17, 3]
上面代码的过程以下面4张图所示,但问题是初始化的大顶堆并不正确,当20与16交换后,算法并无继续对以16为根结点的堆进行调整,致使17的右孩子,大于父结点16.
因而我改进了算法,每次子结点与父结点交换后,需将以子结点为根的彻底二叉树调整为大顶堆,固然,若是父结点大与左右孩子,就不需交换,固然与无须再调整为大顶堆。改进后算法以下:
1 def sift_down(array, start, end): 2 """ 3 调整成大顶堆,初始堆时,从下往上;交换堆顶与堆尾后,从上往下调整 4 :param array: 列表的引用 5 :param start: 父结点 6 :param end: 结束的下标 7 :return: 无 8 """ 9 while True: 10 # 当列表第一个是如下标0开始,结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2; 11 # 若下标以1开始,左孩子则为2*i,右孩子则为2*i+1 12 left_child = 2*start + 1 # 左孩子的结点下标 13 # 当结点的右孩子存在,且大于结点的左孩子时 14 if left_child+1 <= end and array[left_child+1] > array[left_child]: 15 left_child += 1 16 if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时,则交换 17 temp = array[left_child] 18 array[left_child] = array[start] 19 array[start] = temp 20 21 start = left_child # 交换以后以交换子结点为根的堆可能不是大顶堆,需从新调整 22 else: # 若父结点大于左右孩子,则退出循环 23 break 24 25 print(">>", array) 26 27 28 def heap_sort(array): # 堆排序 29 # 先初始化大顶堆 30 first = len(array)//2 -1 # 最后一个有孩子的节点(//表示取整的意思) 31 # 第一个结点的下标为0,不少博客&课本教材是从下标1开始,无所谓吧,你随意 32 for i in range(first, -1, -1): # 从最后一个有孩子的节点开始往上调整 33 print(array[i]) 34 sift_down(array, i, len(array)-1) # 初始化大顶堆 35 36 print("初始化大顶堆结果:", array) 37 38 if __name__ == "__main__": 39 array = [16, 7, 3, 20, 17, 8] 40 print(array) 41 heap_sort(array) 42 print(array)
可是运行下,出错了,下标越界!
Traceback (most recent call last): File "C:/Users/Administrator/PycharmProjects/laonanhai/编程/个人堆排序.py", line 42, in <module> heap_sort(array) File "C:/Users/Administrator/PycharmProjects/laonanhai/编程/个人堆排序.py", line 35, in heap_sort [16, 7, 3, 20, 17, 8] sift_down(array, i, len(array)-1) # 初始化大顶堆 3 File "C:/Users/Administrator/PycharmProjects/laonanhai/编程/个人堆排序.py", line 17, in sift_down if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时,则交换 IndexError: list index out of range >> [16, 7, 8, 20, 17, 3]
经过Debug知道为啥越界了
为了解决越界的问题,加个下标断定,轻松解决,oh year:
if left_child > end: break
初始化大顶堆代码:
1 def sift_down(array, start, end): 2 """ 3 调整成大顶堆,初始堆时,从下往上;交换堆顶与堆尾后,从上往下调整 4 :param array: 列表的引用 5 :param start: 父结点 6 :param end: 结束的下标 7 :return: 无 8 """ 9 while True: 10 11 # 当列表第一个是如下标0开始,结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2; 12 # 若下标以1开始,左孩子则为2*i,右孩子则为2*i+1 13 left_child = 2*start + 1 # 左孩子的结点下标 14 # 当结点的右孩子存在,且大于结点的左孩子时 15 if left_child > end: 16 break 17 18 if left_child+1 <= end and array[left_child+1] > array[left_child]: 19 left_child += 1 20 if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时,则交换 21 temp = array[left_child] 22 array[left_child] = array[start] 23 array[start] = temp 24 25 start = left_child # 交换以后以交换子结点为根的堆可能不是大顶堆,需从新调整 26 else: # 若父结点大于左右孩子,则退出循环 27 break 28 29 print(">>", array) 30 31 32 def heap_sort(array): # 堆排序 33 # 先初始化大顶堆 34 first = len(array)//2 -1 # 最后一个有孩子的节点(//表示取整的意思) 35 # 第一个结点的下标为0,不少博客&课本教材是从下标1开始,无所谓吧,你随意 36 for i in range(first, -1, -1): # 从最后一个有孩子的节点开始往上调整 37 print(array[i]) 38 sift_down(array, i, len(array)-1) # 初始化大顶堆 39 40 print("初始化大顶堆结果:", array) 41 42 if __name__ == "__main__": 43 array = [16, 7, 3, 20, 17, 8] 44 print(array) 45 heap_sort(array) 46 print(array)
输出:
C:\Python34\python3.exe C:/Users/Administrator/PycharmProjects/laonanhai/编程/个人堆排序.py [16, 7, 3, 20, 17, 8] 3 >> [16, 7, 8, 20, 17, 3] 7 >> [16, 20, 8, 7, 17, 3] 16 >> [20, 16, 8, 7, 17, 3] >> [20, 17, 8, 7, 16, 3] 初始化大顶堆结果: [20, 17, 8, 7, 16, 3] [20, 17, 8, 7, 16, 3] Process finished with exit code 0
此时须要交换堆顶与堆尾,可是问题来了,堆顶确定是array[0],但堆尾呢? 由于每次交换堆顶与堆尾后,堆尾下标是会变化的啊。
为了每次交换时都能找到堆尾,我用一个循环。
# 交换堆顶与堆尾 for head_end in range(len(array)-1, 0, -1): # start stop step array[head_end], array[0] = swap(array[head_end], array[0]) # 交换堆顶与堆尾
交换堆顶与堆尾后,堆长度减一,且需从上往下调整成大顶堆。
# 交换堆顶与堆尾 for head_end in range(len(array)-1, 0, -1): # start stop step array[head_end], array[0] = swap(array[head_end], array[0]) # 交换堆顶与堆尾 sift_down(array, 0, head_end-1) # 堆长度减一(head_end-1),再从上往下调整成大顶堆
自此,堆排序算法ending,你会了吗? or 你会装逼了吗?
1 def swap(a, b): # 将a,b交换 2 temp = a 3 a = b 4 b = temp 5 return a,b 6 7 def sift_down(array, start, end): 8 """ 9 调整成大顶堆,初始堆时,从下往上;交换堆顶与堆尾后,从上往下调整 10 :param array: 列表的引用 11 :param start: 父结点 12 :param end: 结束的下标 13 :return: 无 14 """ 15 while True: 16 17 # 当列表第一个是如下标0开始,结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2; 18 # 若下标以1开始,左孩子则为2*i,右孩子则为2*i+1 19 left_child = 2*start + 1 # 左孩子的结点下标 20 # 当结点的右孩子存在,且大于结点的左孩子时 21 if left_child > end: 22 break 23 24 if left_child+1 <= end and array[left_child+1] > array[left_child]: 25 left_child += 1 26 if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时,则交换 27 array[left_child], array[start] = swap(array[left_child], array[start]) 28 29 start = left_child # 交换以后以交换子结点为根的堆可能不是大顶堆,需从新调整 30 else: # 若父结点大于左右孩子,则退出循环 31 break 32 33 print(">>", array) 34 35 36 def heap_sort(array): # 堆排序 37 # 先初始化大顶堆 38 first = len(array)//2 -1 # 最后一个有孩子的节点(//表示取整的意思) 39 # 第一个结点的下标为0,不少博客&课本教材是从下标1开始,无所谓吧,你随意 40 for i in range(first, -1, -1): # 从最后一个有孩子的节点开始往上调整 41 print(array[i]) 42 sift_down(array, i, len(array)-1) # 初始化大顶堆 43 44 print("初始化大顶堆结果:", array) 45 # 交换堆顶与堆尾 46 for head_end in range(len(array)-1, 0, -1): # start stop step 47 array[head_end], array[0] = swap(array[head_end], array[0]) # 交换堆顶与堆尾 48 sift_down(array, 0, head_end-1) # 堆长度减一(head_end-1),再从上往下调整成大顶堆 49 50 51 52 if __name__ == "__main__": 53 array = [16, 7, 3, 20, 17, 8] 54 print(array) 55 heap_sort(array) 56 print("堆排序最终结果:", array)
运行结果:
[16, 7, 3, 20, 17, 8] 3 >> [16, 7, 8, 20, 17, 3] 7 >> [16, 20, 8, 7, 17, 3] 16 >> [20, 16, 8, 7, 17, 3] >> [20, 17, 8, 7, 16, 3] 初始化大顶堆结果: [20, 17, 8, 7, 16, 3] >> [17, 3, 8, 7, 16, 20] >> [17, 16, 8, 7, 3, 20] >> [16, 3, 8, 7, 17, 20] >> [16, 7, 8, 3, 17, 20] >> [8, 7, 3, 16, 17, 20] >> [7, 3, 8, 16, 17, 20] 堆排序最终结果: [3, 7, 8, 16, 17, 20]
时间复杂度:
上图来自:http://blog.csdn.net/hguisu/article/details/7776068
参考博客:http://www.cnblogs.com/dolphin0520/archive/2011/10/06/2199741.html
这篇博客写了好几天了。转发注明出处: http://www.cnblogs.com/0zcl/p/6737944.html