冒泡排序，插入排序，选择排序，快速排序

冒泡排序：

def bubble_sort(lst):
    n = len(lst)
    for i in range(n):
        for j in range(0, n - i - 1):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst

插入排序：

def insertion_sort(lst):
    n = len(lst)
    for i in range(1, n):
        j = i - 1
        key = lst[i]
        while (j >= 0 and lst[j] > key):
            lst[j + 1] = lst[j]
            j -= 1
        lst[j + 1] = key
    return lst

def insertion_sort(lst):
    n = len(lst)
    for j in range(1, n):
    i = j
    while i> 0:
        if lst[i] < lst[i-1]：
            lst[i]，lst[i-1] = lst[i-1]，lst[i]
            else:
                break
        i -=1

选择排序：

li = [54, 26, 93, 17,77,31,44,55,20]
def selection_sort(list):
    n = len(list)
    for i in range(n - 1):
        min_index = i
        for j in range(i + 1, n):
            if list[j] < list[min_index]:
                min_index = j
        if min_index != i:
            list[i], list[min_index] = list[min_index], list[i]


selection_sort(li)
print(li)

快速排序：

def quick_sort(lst):
    if len(lst) <= 1:
        return lst
    # 选取基准元素
    pivot = lst[0]
    # 划分子序列
    left = [x for x in lst[1:] if x < pivot]
    right = [x for x in lst[1:] if x >= pivot]
    # 递归排序子序列
    return quick_sort(left) + [pivot] + quick_sort(right)

lst = [64, 25, 12, 22, 11]
result = quick_sort(lst)
print(result)
# 输出：[11, 12, 22, 25, 64]

1. 冒泡排序：
        冒泡排序算法的基本思路是从列表的左侧开始比较相邻的元素，如果前一个元素大于后一个元素，则交换它们的位置，然后向右移动一个元素并继续比较相邻的元素。这个过程会一直持续到没有元素需比较或者已经完成了全部的比较和交换操作。具体实现步骤如下：

- 外层循环用来控制比较次数，从列表的第一个元素开始，依次比较到最后一个元素。
- 内层循环用来比较相邻的元素并交换它们的位置，每次比较后移动右侧元素的位置。
- 如果右侧元素小于左侧元素，交换两个元素的位置，完成一次比较、交换操作。

在最差情况下，即列表中所有元素都需要比较交换，冒泡排序的时间复杂度为 O(n^2)。

2. 插入排序：
        插入排序算法也是基于比较的排序算法，时间复杂度为 O(n^2)。它的基本思路是将被排序序列分成两个部分：有序和无序。开始时，将第一个元素作为有序部分，其余元素作为无序部分。

每次从无序部分选择一个元素，将其插入到有序部分的合适位置，使得插入后的有序部分还是有序的。因此，对于每个选择的无序部分的元素，需要将它依次与有序部分的元素比较，找到它应该插入的位置。

具体实现步骤如下：

- 外层循环用于选择无序部分的元素，在本例中其从1到n进行循环，因为第0个元素已经是有序的了。
- 内层循环用于往有序部分的合适位置插入选择的无序元素。
- 对于每个无序元素，通过一个 while 循环找到它应该插入的位置，并将它插入到有序部分的相应位置。

尽管算法的时间复杂度与冒泡排序算法相同，但是插入排序算法在比冒泡排序更加高效，因为它只需要交换相邻两个元素，而冒泡排序要交换距离很远的两个元素，需要中间变量的帮助，所以它的空间占用会比插入排序算法更多。

3.选择排序

        选择排序（Selection Sort）是一种简单的基本比较排序算法，其基本思想是在待排序序列中选择最小（或最大）的元素，放到序列的起始位置，然后再将剩余未排定的元素中最小（或最大）的元素选出来放到已排定部分的末尾位置，以此类推，直到所有元素排序完成。

选择排序的算法时间复杂度为O(n²)，空间复杂度为O(1)。虽然时间复杂度比较高，但由于其思路简单易懂，实现也非常容易，因此在简单的排序任务中被广泛使用。

算法步骤如下：

1. 遍历数组，记录当前位元素和当前位的索引。

2. 遍历数组剩下的元素，如果发现一个元素的值小于当前位元素的值，则更新当前位元素和当前位的索引。

3. 当遍历完剩下的元素后，如果发现最小值的索引与当前位的索引不同，则交换两个位置的元素。

4. 重复执行以上步骤，直到数组排序完成。

4.快速排序

        快速排序（Quick Sort）是一种基于划分的排序算法，通过交换数组中的元素来排序，其具体过程如下：

1. 选择一个基准元素，一般选择列表的第一个元素或最后一个元素。

2. 将所有小于基准的元素移到基准左侧，所有大于等于基准的元素移到基准的右侧，形成左右两个子序列。

3. 对左子序列和右子序列分别执行上面两个步骤，直到所有的子序列都排好序。

实现快速排序算法的关键在于如何划分子序列，常用的方法是选定一个基准元素，然后将其它元素分为小于它的一部分和大于它的一部分。一般来说，选取基准元素有多种方式，如选择第一个元素、最后一个元素、中间元素或随机元素等。快速排序采用递归的思路，将一个大的序列分治为多个小的子序列，最终得到排序好的完整序列。