python算法 -- 05 排序

冒泡排序

• 外层循环控制遍历的轮数，内层循环用于比较相邻元素并进行交换
• 每一轮将剩下的元素里最大的放到最后

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]
n = len(l)

for i in range(n-1):
    for j in range(n-1-i):
        if l[j] > l[j+1]:
            l[j], l[j+1] = l[j+1], l[j]

print(f'冒泡排序后:{l}')

>冒泡排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]

选择排序

• 外层循环控制遍历的轮数，内层循环用于比较相邻元素并进行交换
• 每轮找到剩下元素里最小元素的索引，并放到未排序区域的第一个位置

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]
n = len(l)

for i in range(n-1): 
    min_index = i
    for j in range(i+1, n):
        if l[j] < l[min_index]:
            min_index = j
    if min_index != i:
        l[i], l[min_index] = l[min_index], l[i]

print(f'选择排序后:{l}')

>选择排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]

插入排序

• 外层循环控制轮次，给第2个到第n个元素找到合适的插入位置
• while循环通过相邻元素依次比较，将元素插入到指定位置

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]
n = len(l)

for i in range(1, n):
    key = l[i]
    j = i - 1
    while j >= 0 and l[j] > key:
        l[j+1] = l[j]
        j -= 1
    l[j+1] = key
    
print(f'插入排序后:{l}')

>插入排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]

快速排序

• 采用递归和分治的思想
• 通过基准元素将列表分割成2部分

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]  # 选择中间元素作为基准值
    left = [x for x in arr if x < pivot]  # 小于基准值的元素
    middle = [x for x in arr if x == pivot]  # 等于基准值的元素
    right = [x for x in arr if x > pivot]  # 大于基准值的元素
    return quick_sort(left) + middle + quick_sort(right)


print(f'快速排序后:{quick_sort(l)}')

>快速排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]

希尔排序

• 核心思想是将相距某个增量的元素组成一个子序列，然后对子序列进行插入排序，随着增量逐渐减小，子序列的长度逐渐增加，当增量减小为1时，整个序列就是一个有序序列
• 插入排序的一种改进版本，也称为缩小增量排序。

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap >= 1:
        for i in range(gap, n):
            j = i
            while (j-gap) >= 0:
                if arr[j] < arr[j - gap]:
                    arr[j], arr[j-gap] = arr[j-gap], arr[j]
                    j -= gap
                else:
                    break
        gap //= 2
    return l

print(f'希尔排序后:{shell_sort(l)}')

>希尔排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]

归并排序

• 采用递归和分治的思想
• 将数据分为左右2个部分分别排序，最终合并起来

l = [2, 45, 33, 68, 23, 45, 78, 99, 67, 10]

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)


def merge(left, right):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    while i < len(left):
        result.append(left[i])
        i += 1

    while j < len(right):
        result.append(right[j])
        j += 1

    return result


print(f'归并排序后:{merge_sort(l)}')
>归并排序后:[2, 10, 23, 33, 45, 45, 67, 68, 78, 99]