排序

参考：https://blog.csdn.net/mrlevo520/article/details/77829204
自己总结一下

归并排序

通过先递归的分解数列，再合并数列就完成了归并排序。
#写code：分成很小很小的小问题

 def merge(left,right):
    res=[]
    while left and right:
        res.append( left.pop(0) if left[0]<=right[0] else right.pop(0) ) #<=否则会漏项   变量.pop()默认弹出最后一个
    while left:
        res.append( left.pop(0))
    while right:
        res.append(right.pop(0))
    return res

def mergeSort(relist):
    if len(relist)<2: return relist
    mid = len(relist)//2  #习惯性从中间开始分  mid必须是int type,故//向下取整
    left = mergeSort(relist[:mid])
    right = mergeSort(relist[mid:])  #之上都是 分割
    return merge(left,right)    #此步 合并

print(mergeSort([1,5,2,6,9,3]))

插入排序

1.从下标为1（下标0没啥好插的）的元素开始，遍历依次取元素a[i]
与其前半部分有序序列的循环遍历比较，直到遇到第一个比a[i]大的元素（这里默认是从小到大排序），此时的下标为j，然后将a[i]插入到j的位置；
2.因为前面的插入，导致后面元素向后推移一个位置，把原来下标i的元素(此时在位置a[i+1])弹出即可；
重复进行第1步到第2步

def insertSort(relist):
    if len(relist)<2: return relist
    for i in range(len(relist)):
        for j in range(i):
            if relist[j] > relist[i]:
                relist.insert(j,relist[i])  #object.insert(j,object)将object插入object[j],len(object)增长1
                relist.pop(i+1)   #因之前relist[i]变到了位置[i+1]
    return relist

print(insertSort([1,5,2,6,9,3]))

快速排序

1.先从数列中取出一个数作为基准数。
2.分区过程，将比这个数大的数全放到它的右边，小于或等于它的数 全放到它的左边。
3.再对左右区间重复第二步，直到各区间只有一个数。

 # 快排 分片的思想+递归的思想，这是取了第一个为基准值
def quickSort(array):
    if len(array)<2: return array
    pivot = array[0]
    smallLeft = [i for i in array[1:] if i<pivot]
    bigRight = [i for i in array[1:] if i>=pivot]
    return quickSort(smallLeft) + [pivot] + quickSort(bigRight)  #中间值pivot一定要加[]，变成list

#print(quickSort([1,5,2,6,9,3]))

堆排序

1.创建最大堆:将堆所有数据重新排序，使其成为最大堆
2.堆排序:移除位在第一个数据的根节点，并做最大堆调整的递归运算
[.最大堆调整:作用是保持最大堆的性质，是创建最大堆的核心子程序]

堆节点的访问
通常堆是通过一维数组来实现的。在阵列起始位置为0的情况中
对任何父节点I
(1)父节点i的左子节点在位置(2i+1);
(2)父节点i的右子节点在位置(2i+2);
(3)子节点i的父节点在位置floor((i-1)/2);

def MAX_Heapify(heap,HeapSize,root):#在堆中做结构调整使得父节点的值大于子节点
    left = 2*root+1
    right =2*root+2
    larger = root
    if left < HeapSize and heap[left]>heap[root]:
        larger=left
    if right < HeapSize and heap[right]>heap[root]:
        larger=right
    if larger!=root:   #如果做了堆调整则larger的值等于左节点或者右节点的，这个时候做对调值操作
        heap[larger],heap[root] = heap[root], heap[larger]
        MAX_Heapify(heap,HeapSize,larger)

def Build_MAX_Heap(heap):#[初始构造仅一次]构造一个堆，将堆中所有数据重新排序
    for i in range( (len(heap)-2)//2,-1,-1 ): #从后往前出数(从树倒数第二层开始构造)
        MAX_Heapify(heap,len(heap),i)

def HeapSort(heap):#将根节点取出与最后一位做对调，对前面len-1个节点继续进行对调整过程。
    Build_MAX_Heap(heap)  #堆heap已调整完毕
    for i in range(len(heap)):
        heap[0],heap[i] = heap[i],heap[0]
        MAX_Heapify(heap,i,0)  #对前面len-1 等价于每次弹出最后一个
    return heap

a = [30,50,57,77,62,78,94,80,84]
print(a)
HeapSort(a)
print(a)

需多看几遍熟悉起来
https://blog.csdn.net/minxihou/article/details/51850001 写得很好参考