python数据结构的多种排序算法

# 选择排序法
def selection_sort(my_list):
    i = 0
    while i < len(my_list):
        min_index = i
        j = i + 1
        while j < len(my_list):
            if my_list[j] < my_list[min_index]:
                min_index = j   # 该循环主要用于搜索当前列表的最小值

            j += 1
        if my_list[min_index] != my_list[i]:  # 如果最开始我们假设的第一个位置的值并不是最小值，就将俩交换
            my_list[min_index], my_list[i] = my_list[i], my_list[min_index]

        i += 1



# 冒泡排序法
def bubble_sort(my_list):
    n = len(my_list)
    swapped = False
    while n > 1:
        i = 1
        while i < n:
            if my_list[i] < my_list[i - 1]:
                my_list[i], my_list[i - 1] = my_list[i - 1], my_list[i]
                swapped = True
            i += 1
        n -= 1          


# 插入排序法
def insert_sort(my_list):
    num = 1
    while num < len(my_list):
        i = num - 1
        need_item = my_list[num]
        while i >= 0:
            if need_item < my_list[i]:
                my_list[i + 1] = my_list[i]
                i -= 1
            else:
                break
        my_list[i + 1] = need_item
        num += 1


# ========================快速排序=====================
def quick_sort(my_list):
    quick_helper(my_list, 0, len(my_list) - 1)


def quick_helper(lyst, left, right):
    """递归调用方法"""
    if left < right:  # 判断分割好的方向的个数是否小于2
        boudary = get_boundary_postion(lyst, left, right)  # 获取边界点的位置
        quick_helper(lyst, left, boudary - 1)  # 左边的子列表
        quick_helper(lyst, boudary + 1, right)  # 右边的子列表


def get_boundary_postion(lyst, left, right):
    """
    获取分界点的位置
    :param lyst: 列表或者子列表
    :param left: 开头位置
    :param right: 结束位置
    return: 返回边界点的位置
    """
    middle = (left + right) // 2  # 获取中间位置 '//'是取商
    datum_point = lyst[middle]  # 选择中间位置为基准点
    lyst[middle] = lyst[right]  # 将基准点和结束位置进行交换
    lyst[right] = datum_point
    boudary = left  # 在列表的最前面设置一个边界点
    for i in range(left, right):
        if lyst[i] < datum_point:  # 遍历查找第一个小于基准点的值
            lyst[boudary], lyst[i] = lyst[i], lyst[boudary]  # 交换边界点与查找到的值得位置
            boudary += 1
    # 将边界点的下一个位置的点与已经在最后的基准点交换，
    # 这个时候基准点右边就全是小于基准点的值, 左边是大于的
    lyst[boudary], lyst[right] = lyst[right], lyst[boudary]  
    return boudary


# ==================合并排序======================
def merge_sort(my_list):
    """排序的主要方法"""
    copy_lyst = my_list.copy()
    merge_helper(my_list, copy_lyst, 0, len(my_list)-1)


def merge_helper(lyst, copy_lyst, left, right):
    """递归函数"""
    if left < right:
        middle = (left + right) // 2
        merge_helper(lyst, copy_lyst, left, middle)
        merge_helper(lyst, copy_lyst, middle+1, right)
        merge_(lyst, copy_lyst, left, middle, right)


def merge_(lyst, copy_lyst, left, middle, right):
    """
    合并函数
    :param lyst --原始列表
    :param copy_lyst --一个和原始列表具有相同大小的列表
    :param left  --起始位置
    :param middle --中值
    :param right --结束位置
    """
    i1 = left  # 左边子列表的起始值,
    i2 = middle + 1  # 右边子列表的起始值
    for i in range(left, right + 1):
        if i1 > middle:
            copy_lyst[i] = lyst[i2]
            i2 += 1
        elif i2 > right:
            copy_lyst[i] = lyst[i1]
            i1 += 1
        elif lyst[i1] < lyst[i2]:  # 比较两个子列表的最小值
            copy_lyst[i] = lyst[i1]
            i1 += 1
        else:
            copy_lyst[i] = lyst[i2]
            i2 += 1

    for i in copy_lyst:
        lyst[i] = copy_lyst[i]




num = [1, 3, 4, 2, 1]
merge_sort(num)
print(num)

其实既然使用python来实现排序算法，在实现两个位置交换的功能中，我应该也使用底层的方式，而不是使用python已经写好的交换方式

def swapped(lyst, index1, index2):
    temp = lyst[index1]
    lyst[index1] = lyst[index2]
    lyst[index2] = temp