堆是完全二叉树
子树是不相交的
度 节点拥有子树的个数
满二叉树：
每个节点上都有子节点（除了叶子节点）
完全二叉树：
叶子结点在倒数第一层和第二层，最下层的叶子结点集中在树的左部
，在右边的话，左子树不能为空
二叉搜索树：
左边子节点小于父节点，右边子节点大于父节点
堆：
也叫队列，在堆尾插入，在堆头取出
最大堆：
最上边比下边的两个数都大，所有的节点都满足这个规则
最小堆：
父节点一定比两个子节点要小
特征：
堆起始坐标从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)
这个循环要理解一下：
这个循环调用，表示从最下层的子树，开始实现最大堆，这个就是我刚才说的从最下层开始建立最大堆的过程