快速排序

基于分治的思想，通过选择一个基准元素，将待排序序列分成两部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素，然后递归地对两个子排序进行排序。对于基准元素的选择，其一般是选择序列的第一个元素或者最后一个元素。
这个代码感觉效率比较低：

def quicksort(arr0):
    if len(arr0) <= 1:
        return arr0
    pivot = arr0[len(arr0) // 2]  # 选择基准元素
    left = [x for x in arr0 if x < pivot]  # 小于基准的元素
    middle = [x for x in arr0 if x == pivot]  # 等于基准的元素
    right = [x for x in arr0 if x > pivot]  # 大于基准的元素
    return quicksort(left) + middle + quicksort(right)

# 示例用法
arr = [3, 1, 7, 2, 5, 4, 3, 11, 2, 3, 4, 5, 6, 7, 8, 9, 0]
sorted_arr = quicksort(arr)
print(sorted_arr)

使用双指针（双边循环）实现的快速排序的代码示例（讲解快速排序算法_哔哩哔哩_bilibili）：

def quick_sort(arr, low, high):
    if low < high:
        # 选择枢纽元素
        pivot = arr[low]
        i = low
        j = high

        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)


# 测试示例
arr = [9, 1, 0, 5, 4]
quick_sort(arr, 0, len(arr) - 1)
print("Sorted array:", arr)

冒泡排序

冒泡排序的基本思想是通过不断地比较相邻的元素，将较大（或较小）的元素逐渐交换到列表的一端。在每一轮遍历中，将最大（或最小）的元素冒泡到列表的末尾，因此称为冒泡排序。

def bubble_sort(arr):
    n = len(arr)
    # 遍历n-1轮
    for i in range(n - 1):
        # 每轮遍历比较相邻的元素
        for j in range(n - 1 - i):
            # 如果前一个元素大于后一个元素，则交换它们
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

# 测试示例
arr = [9, 1, 0, 5, 4]
bubble_sort(arr)
print("Sorted array:", arr)

归并排序

归并排序（Merge Sort）是一种基于分治思想的排序算法。它将待排序的数组分成两个较小的子数组，分别对两个子数组进行排序，然后将排好序的子数组合并成一个有序的数组。

归并排序的基本思想是不断地将数组一分为二，直到每个子数组只包含一个元素。然后，逐层合并相邻的子数组，直到最终得到完全排序的数组。

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

    # 将数组一分为二
    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    # 递归地对左右两个子数组进行排序
    left = merge_sort(left)
    right = merge_sort(right)

    # 合并两个已排序的子数组
    return merge(left, right)


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

    # 按照从小到大的顺序合并两个子数组
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            merged.append(left[i])
            i += 1
        else:
            merged.append(right[j])
            j += 1

    # 将剩余的元素添加到合并后的数组中
    while i < len(left):
        merged.append(left[i])
        i += 1
    while j < len(right):
        merged.append(right[j])
        j += 1

    return merged

# 测试示例
arr = [9, 1, 0, 5, 4]
sorted_arr = merge_sort(arr)
print("Sorted array:", sorted_arr)