python堆排序

堆是完全二叉树

子树是不相交的

度 节点拥有子树的个数

满二叉树：

每个节点上都有子节点（除了叶子节点）

完全二叉树：

叶子结点在倒数第一层和第二层，最下层的叶子结点集中在树的左部

，在右边的话，左子树不能为空

二叉搜索树：

左边子节点小于父节点，右边子节点大于父节点

堆：

也叫队列，在堆尾插入，在堆头取出

最大堆：

最上边比下边的两个数都大，所有的节点都满足这个规则

最小堆：

父节点一定比两个子节点要小

特征：

堆起始坐标从1开始

如果用列表表示一个堆：

堆的坐标从1开始算

当前坐标是i

左节点坐标是2i

右节点坐标是2i+1

父节点坐标是i//2 取整

如果想找到最后一个带有子节点的节点坐标：

堆的长度//2

[0,1,2,3,4,5]

[0,1,2,3,4,5,6,7]

1

2  2*1+1=3

2*2  2*2+1=5

0

1        2

3    4    5   6

堆的坐标从0开始算

当前坐标是i

左节点坐标是2i+1

右节点坐标是2i+2

父节点坐标是(i-1)//2 取整

如果想找到最后一个带有子节点的节点：

(堆的长度-1)//2

父节点的位置是K//2,它的左节点是2k，右节点是2k+1

在堆里插入一个元素：上滤

最大堆：

所有的父节点必须大于它的两个子节点

如果将新元素增加到堆的末尾：加一个88

要保证最大堆的规则，新元素和父节点调整交换的操作叫做上滤

只要插入的节点比父节点小，就不做交换了，不交换那么排序就停止了

当发生了新插入节点和父节点没有交换的情况，那么上滤过程及结束了

删除根元素：下滤

删除堆顶元素，两个子元素比较，大的上去，空出的元素的两个子元素继续比较，大的再上去。。。

最小堆：

所有的父节点必须小于它的两个子节点

堆排序：

算法：一个列表是待排序的

构造最大（小）堆：

最大堆的规则：堆中所有的父节点必须都大于它的子节点

最大堆中的最大值是：根

最小堆的规则：堆中所有的父节点必须都小于它的子节点

最小堆中最小值是：根

排序：

假设使用最大堆

1生成一个空列表存储排序后的结果

2将待排序的list构造成最大堆

3将最大堆的根元素放到空列表中，将剩余的元素通过下滤重新构造最大堆

4然后重复3的步骤，知道所有的元素都当过一次最大堆

拆解过程：

列表中的元素是排好序的，并且是降序的

result =[]

5

3    4

1  2

第一次：result:[5]

3    4

1  2

剩下的元素要构造新的最大堆

4

3

1  2

第二次：result:[5，4]

3

1  2

再次构造最大堆

第三次：result:[5，4，3]

1 2

再次构造最大堆

2

1

第三次：result:[5，4，3 ,2]

1

再次构造最大堆

第四次：result:[5，4，3,2，1]

完成了所有元素当过一次堆的根元素条件，结束堆排序

构造最大堆的时候，如何构造：

从堆的最下层开始构造，每构造一次进行一次上滤

将最大值向上传递。

下滤是从堆顶取值

代码：

# encoding=utf-8

#左叶子、右叶子和父节点，三个元素，找到最大的一个

def maxHeap(heap,heapSize,i):#构造最大堆

#参数heap为一个list，heapsize是指定这个list要操作的长度

#i为某个节点，假设我们传递的是列表的倒数第三个元素

#它的左节点坐标：2i

#那么它的右节点坐标：2i + 1

#它的父节点：i/2

left = 2*i +1

right = 2*i +2

larger = i#当前节点的值

#通过2次if的比较，将left、right和larger三者的最大值找到

#然后将最大值所在的坐标赋值给larger

if left < heapSize and heap[larger] < heap[left]:

larger = left

if right < heapSize and heap[larger] < heap[right]:

larger = right

#以上两步是把三个节点中，最大的值的坐标给了larger

#如果lager的值不是i，说明i的值需要和最大值进行交换

#因为i的坐标是最大堆的堆顶，所以必须是最大值

#如果不是i最大，则说明左结点，或者右节点最大，交换值

#后，说明下面的堆有可能需要进行调整，所以通过递归来

#建立左（右）结点下的最大堆。

#如果最大值就是i，没有进行交换值，所以不需要进行建立

#左（右）结点下的最大堆，这是因为

#做交换，如果最大值的坐标不是当前节点的坐标，说明更大的是左右节点之一

#就把最大那个和当前节点做一个交换，这样最大的就跑到上边去了

if larger != i:

heap[i],heap[larger] = heap[larger],heap[i]

maxHeap(heap,heapSize,larger)#递归调用larger是左节点坐标或者右节点坐标，继续去找下边的最大值，做交换

#如果发生了larger =i 的情况，则次函数调用结束

#以上步骤完成，堆顶坐标为i坐标的最大子堆建立好了

def buildMaxHeap(heap):

#heap参数是未排序、未建堆的list

heapSize = len(heap)

#堆的长度//2可以找到堆里面的

#最后一个带有子节点的节点

#循环可以实现从堆的最下层节点开始建堆

#每次建立的堆都是一个最大堆

#简单来说把所有字段都建成最大堆

#然后组成了最终的最大堆

for i in range((heapSize-1)//2 -1,-1,-1):

maxHeap(heap,heapSize,i)

#(heapSize-1)//2是算出来当前堆中最后一个含有子节点的坐标

'''

5

3      4

2   1  -1

'''

def heapSort(heap):

#先把所有元素先建立一个最大堆

buildMaxHeap(heap)

#将堆中所有的元素都遍历一遍

#让每个元素都做一次堆顶

#然后将堆顶的每个元素都换到堆的最后一个节点

for i in range(len(heap)-1,-1,-1):

heap[0],heap[i] = heap[i],heap[0]

#maxheap中的i是列表的长度，这样可以防止追加到

#堆后面的元素重新被当做最大堆元素进行建队

maxHeap(heap,i,0)

return heap

#第一次循环的时候，把最大值放到了列表最后面

#把最后一个值（肯定不是最大值）放到了堆顶，然后把不包含最后一个元素的

#剩余元素，重新进行最大堆排序

#第二次循环的时候，把堆顶（次大值）放到列表倒数的第二个位置，然后把不包含最后

#两个元素的剩余元素，重新进行建立最大堆

#。。。。

#循环结束，那么列表的数据就排好了

if __name__ == '__main__':

heap1 = [3,4,5,6,23,4,1,1,23,45,6678]

print (heap1)

heapSort(heap1)

print (heap1)

算法：

将一个未排序的list,做成最大堆

buildMaxHeap函数通过maxHeap函数构造了最大堆

第一次从最大堆取出的元素和列表的最后一个的元素交换

位置，我们就找到了最大值

剩余的元素，进行新的最大堆建立

第二次从新建的最大堆堆顶取出来最大值，这个值和

列表中的倒数第二个数进行交换，那么第二大的值就找到了，

此时，最大值在列表的最后，第二大值在列表的倒数

第二个元素

第三次。。。。。重复上面的过程

直到所有的元素都被交换过一次位置

刚才有一个地方讲解有偏差

maxHeap 这个函数的交换逻辑，应该是既不算上滤，也不算下滤

上滤：新插入元素和父节点比对，发生交换。下滤：左右节点比对后发生交换

maxHeap 这个函数的交换逻辑是三个数找到最大的，和上滤下滤还是有一些区别。

for i in range((heapSize-1)//2,-1,-1):
        maxHeap(heap,heapSize,i) 
这个循环要理解一下：

这个循环调用，表示从最下层的子树，开始实现最大堆，这个就是我刚才说的从最下层开始建立最大堆的过程