排序（快速、堆排序、归并排序）---python

#快速排序

def quick_sort(l,left,right):
    if left < right: #待排序的区域至少有两个元素
        mid = partition(l,left,right)
        quick_sort(l,left,mid - 1)
        quick_sort(l,mid + 1,right)
    return l

def partition(l,left,right):
    tmp = l[left]
    while left < right:
        while left < right and l[right] >= tmp:
            right -= 1
        l[left] = l[right]
        while left < right and l[left] <= tmp:
            left += 1
        l[right] = l[left]
    l[left] = tmp
    return  left

print(quick_sort([4,5,6,9,2,3,8,7],0,7))

def quick_sort1(l):
    if len(l) < 2:
        return l
    tmp = l[0]
    left = [v for v in l[1:] if v <= tmp]
    right = [v for v in l[1:] if v > tmp]
    left = quick_sort1(left)
    right = quick_sort1(right)
    return  left + [tmp] + right
print(quick_sort1([4,5,6,9,2,3,8,7]))

#二叉树   度不超过2的树  满二叉树  完全二叉树
#树的存储方式（链式存储，顺序存储-列表）  完全二叉树：父节点下标为i，左节点下标为2i+1，右节点下标为2i+2,孩子节点为i，父节点为i-1//2
#堆是特殊的完全二叉树     大根堆（所有节点比父节点小），小根堆（任意一节点比父节点要大）
#堆排序
def sift(l,low,high):
    #l表示树，low表示树根，high表示树最后一个节点的位置
    tmp = l[low]
    i = low  # i指向空位，j指向两个孩子
    j = 2 * i + 1 # j指向空位的左孩子
    while j <= high:  #循环退出的第二种情况：j > high ，说明空位i 是叶子节点
        if j + 1 <= high and l[j] < l[j+1]:#如果右孩子存在并且比左孩子大，指向右孩子
            j += 1
        if l[j] > tmp:
            l[i] = l[j]
            i = j
            j = 2 * i + 1
        else:  #循环退出的第一种情况：j位置的值比tmp小，说明两个孩子都比tmp小
            break
    l[i] = tmp

def  heap_sort(l):
    n = len(l)
    #1.构造堆
    for low in range(n//2 - 1,-1,-1):
        sift(l,low,n-1)
    #2.挨个出数
    for high in range(n-1,-1,-1):
        l[0], l[high] = l[high],l[0]
        sift(l,0,high-1)
    return l

print(heap_sort([4,5,6,12,9,2,3,8,7]))

 现在有n个数，设计算法找出前k大的数（k < n）
1.先排序后切切片2.lowB三人组 3.堆

#归并排序

def merge(l, low, mid, high):
    #列表两段有序：[low, mid] [mid+1, high]
    i = low
    j = mid + 1
    l_tmp = []
    while i <= mid and j <= high:
        if l[i] <= l[j]:
            l_tmp.append(l[i])
            i += 1
        else:
            l_tmp.append(l[j])
            j += 1
    while i <= mid:
        l_tmp.append(l[i])
        i += 1
    while j <= high:
        l_tmp.append(l[j])
        j += 1
    for i in range(low,high + 1):
        l[i] = l_tmp[i - low]
    #l[low:high + 1] = l_tmp
l = [2,5,7,8,9,1,3,4,6]
merge(l,0,4,8)
print(l)


#归并排序  先分开再归并   时间复杂度：O(nlogn) 空间复杂度：O(n)
def merge_sort(l, low, high):
    if low < high:
        mid = (low + high) // 2
        print(l[low:mid + 1],l[mid + 1,high+1])
        merge_sort(l, low, mid)
        merge_sort(l,mid + 1, high)
        merge(l, low, mid, high)
        print(l[low: high + 1])

#两个有序列表进行排序

def merge2list(l1,l2):
    l = []
    i = 0
    j = 0
    while i < len(l1) and j < len(l2):
        if l1[i] <= l2[j]:
            l.append(l1[i])
            i += 1
        else:
            l.append(l2[j])
            j += 1
    while i < len(l1):
        l.append(l1[i])
        i += 1
    while j < len(l2):
        l.append(l2[j])
        j += 1
    return l
l1 = [3,4,5,6]
l2 = [7,9,11,12]
l = merge2list(l1,l2)
print(l)