【Python】 排序

1. 冒泡排序  

最差进行n-1 趟排序，每次排序【通过交换】挤出一个最大值放在末尾

l = list(map(int, input().split(' ')))
n = len(l)
for i in range(1, n):  # i 从1到n-1 表示排序次数 最差需要n-1趟排序
    for j in range(n - i):  # j 从第一个位置【0】到第n-i个位置【n-i-1】
        if l[j] > l[j + 1]:
            l[j], l[j + 1] = l[j + 1], l[j]

print(l)

# 输入：3 1 2 4 5
# 输出：[1, 2, 3, 4, 5]

2. 选择排序 

每次在未排序的序列中选择一个最小值通过与未排序序列首元素【交换】放到未排序序列的首部 最差需要n-1趟

l = list(map(int, input().split(' ')))
n = len(l)
for i in range(n-1): # 第i趟，每趟会使有序序列元素个数+1
    tem = l[i]
    for j in range(i + 1, n): 
        tem = min(tem, l[j]) # 选择无序序列中最小的元素
    index = l.index(tem) # 获取最小元素的索引
    l[index], l[i] = l[i], l[index] # 交换

print(l)

# 输入： 5 4 2 1 3
# 输出： [1, 2, 3, 4, 5]

3. 插入排序 

前i个元素为有序序列，后n-i个元素为无序序列，每次将无序序列中第一个元素【插入】到有序序列的合适位置

# 第一种
l = list(map(int, input().split()))
n = len(l)
for i in range(1, n): # 最多走n-1趟，i表示无序序列第一个元素
    for j in range(i - 1): 
        if l[i] < l[0]: # 小于有序序列最小值 直接头部插入
            l.insert(0, l.pop(i))
        elif l[j] < l[i] < l[j + 1]: # 正常情况插入中间
            l.insert(j + 1, l.pop(i))
print(l)

# 第二种 (借鉴力扣上的)
l = list(map(int, input().split()))
n = len(l)
for i in range(1, n):
    tem = l[i]
    j = i
    while j > 0 and l[j - 1] > tem: # 若满足，每次向右移动一个位置
        l[j] = l[j - 1]
        j -= 1
    l[j] = tem # 找到合适位置进行插入
print(l)

# 输入： 5 4 1 3
# 输出： [1, 3, 4, 5]

4. 希尔排序  <T(n)<

设置一个间隔gap，每趟根据gap，将数组分组进行【插入排序】，gap不断减小直到1

def insertsort(item, l, n, gap): # 插入排序算法
    for i in range(item + gap, n, gap):
        tem = l[i]
        j = i
        while j > item and l[j - gap] > tem:
            l[j] = l[j - gap]
            j -= gap
        l[j] = tem


l = list(map(int, input().split()))
n = len(l)
gap = n // 2

while gap >= 1: # gap=1为最后一趟
    for item in range(gap):  # 每趟有gap组
        insertsort(item, l, n, gap) # 每组进行插入排序
    gap = gap // 2

print(l)

# 输入： 5 4 1 2 6 7 3 

# 输出： [1, 2, 3, 4, 5, 6, 7]

5. 归并排序  

将序列递归地从中间拆分，直到子序列长度为1，然后将子序列进行排序归并，

def mergeSort(l):
    # 递归结束条件
    if len(l) <= 1:
        return l

    # 分解递归
    mid = len(l) // 2
    left = mergeSort(l[0:mid])
    right = mergeSort(l[mid:])
    
    # 合并
    merged = []
    while left and right:
        if left[0] < right[0]:
            merged.append(left.pop(0))
        else:
            merged.append(right.pop(0))
    merged.extend(left if left else right)
    return merged


l = list(map(int, input().split()))
print(mergeSort(l))

# 输入： 4 2 1 6 3
# 输出： [1, 2, 3, 4, 6]

6. 快速排序 

利用low high相当于指针的功能，根据基准点，把比基准点小的放到左边，比基准点大的放到右边，直到元素个数为一，递归完成

import random


def quick_sort(arr, low, high):
    if low >= high:  # 递归结束
        return
       
    # 随机选取作为基准点
    mid = random.randint(low, high)
    arr[low], arr[mid] = arr[mid], arr[low]
    pivot = arr[low]
    i = low + 1
    for j in range(i, high + 1):
        # 比基准点小的就与当前操作点i交换 (i类似于一个指针的功能)
        if arr[j] < pivot:
            arr[i], arr[j] = arr[j], arr[i]
            i += 1
    arr[i - 1], arr[low] = arr[low], arr[i - 1]  # i-1为基准点当前的位置
    # 按照左右子序列继续递归
    quick_sort(arr, low, i - 2)
    quick_sort(arr, i, high)


arr = list(map(int, input().split()))
quick_sort(arr, 0, len(arr) - 1)
print(arr)

输入： 6 5 4 2 1 3 9 0
输出： [0, 1, 2, 3, 4, 5, 6, 9]