Python 实现冒泡、选择、快速、归并排序

冒泡排序：

两两比较，大的放最后面

num_list=[3,1,81,5,7,90,2]
l=len(num_list)
for i in range(l-1):
    # print('i',i)
    for j in range(l-i-1):   #j循环到倒数第2个
        if num_list[j] > num_list[j+1]:
            num_list[j],num_list[j+1] = num_list[j+1],num_list[j]
        # print(num_list)
print(f'排序后列表是{num_list}')

选择排序

每轮选个最小的，从左到右放

num_list=[3,1,81,5,7,90,2]
l=len(num_list)
for i in range(l-1):
    min_idx=i
    for j in range(i+1,l):
        if num_list[j] < num_list[min_idx]:
            min_idx = j
    num_list[i],num_list[min_idx] = num_list[min_idx],num_list[i]
    print(f'第{i} lun {num_list}')
print(num_list)

快速排序

占坑原则，每轮都会为基准值找到它该在的坑
时间复杂度：O（nlogn）~O(n^2)
空间复杂度：O（1）

def quick_sort(arr,i,j):
    if i >= j:
        return
    low,high = i,j
    pivot = arr[i]

    while i < j :
        while i < j and arr[j] >= pivot:
            j -= 1
        arr[i] = arr[j]

        while i < j and arr[i] <= pivot:
            i += 1
        arr[j] = arr[i]
    arr[i] = pivot

    quick_sort(arr,low,i-1)
    quick_sort(arr,i+1,high)

    return arr
if __name__=='__main__':
    num_list = [3, 1, 81, 5, 7, 90, 2,123,3,15,4]
    quick_sort(num_list,0,len(num_list)-1)  #会修改内存中的数据
    print(num_list)

归并排序

先分组，分到每组只有一个元素，小组排序后，再归并

时间复杂度：O（nlogn）
空间复杂度：O（n）

def merge(left, right):
    l, r = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    result.extend(left)
    result.extend(right)
    return result


def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    num = len(arr) // 2
    left = merge_sort(arr[:num])
    right = merge_sort(arr[num:])

    return merge(left, right)

if __name__ =='__main__':
    num_list = [3, 1, 81, 5, 7, 90, 2,2,2,76,76,99, 123, 3, 15, 4]
    print(merge_sort(num_list))