Python-排序算法

  1、选择排序

概念：从第一个元素到最后一个元素中选择出一个最小的元素，跟第一个元素进行交换，然后从第二个元素到最后一个元素中选择出来一个最小的元素，然后和第二个元素进行交换，然后继续选择最小的元素进行交换，直到这些元素排列完成。

#选择排序
#定义函数选择排序
def SelectSort(list):
    #获取列表长度
    n = len(list)
    #比较的轮数
    for i in range(0 ,n-1):
        #定义变量，表示最小值的索引，假设第一轮 索引为0的最小
        min_index = i
        #因为假设第一轮索引值0的元素最小，需要第一个元素和其他元素的元素比较，i和i+1 的元素进行比较，一直到n
        for j in range(i+1, n):
            #比较过程，如果j(最小值索引的下一个元素）比最小值索引要小，那么将j的值赋值给min_index
            if list[j] < list[min_index]:
                #min_index永远是最小值
                min_index = j
        #如果min值变化了，说明最小值不是它，那么就进行交换
        if min_index != i:
            list[i], list[min_index] = list[min_index], list[i]
            print(list)

#测试
if __name__ == '__main__':
    list = [5, 2, 3, 8, 4]
    SelectSort(list)
    

2、冒泡排序

概念：通过不断比较相邻两个的元素，将数值大的元素往后排序。将第一个元素和相邻的元素进行比较，如果大于相邻的元素则进行交换，然后在比较第二个元素，如果前者大于后者，进行交换，直到最大的元素被移动到最后的位置。

#冒泡排序
#定义函数，表示冒泡排序
def BubbleSort(list):
    #定义变量，获取列表长度
    n = len(list)
    #比较的轮数
    for i in range(0, n-1):
        # j 代表的是每一轮要比较的次数，如第一轮要比较四次，那么就是 0 1 2 3 四次 第二轮比较的次数就是三次。
        for j in range(0, n - i - 1):
            #比较过程
            if list[j] > list[j+1]:
                list[j], list[j+1] = list[j+1], list[j]
        print(list)

#测试
if __name__ == '__main__':
    list = [3, 4, 7, 2, 5]
    BubbleSort(list)

 3、插入排序

概念：将列表的第二个元素和第一个元素进行比较，如果小于第一个元素则进行交换，然后第三个元素和前两个元素进行比较，插入合适的位置，第四个元素和前三个元素进行比较，并插入合适的位置，直到最后一个元素。

#插入排序
#定义函数
def insertsort(list):
    n = len(list)
    #i 表示列表中元素的索引，从第二个元素开始，假设第一个元素是有序，剩下的元素就是无序的，从第二个元素和第一个元素进行比较，剩下的元素依次和有序的比较
    for i in range(1, n):
        #表示每一轮元素（索引）比较，(0, -1)表示递减 第一轮：1和0比较 第二轮：2和1比较 1和0比较 第三轮：3和2 2和1 1和0 .........
        for j in range(i, 0, -1):
            #如何第二个元素(索引）比第一个元素小，那么就交换
            if list[j] < list[j-1]:
                #交换过程
                list[j], list[j-1] = list[j-1], list[j]
        print(list)

#测试
if __name__ == '__main__':
    list = [3, 1, 6, 9, 2]
    insertsort(list)

4、快速排序

概念：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都 要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序 序列。

# 1. 定义函数, 实现: 插入排序.
def quick_sort(my_list, start, end):       # start:0,  end: 列表长度-1
    # 1.1 递归出口, 只要start >= end, 说明排好顺序了, 程序结束.
    if start >= end:
        return
    # 1.2 定义分界值, 假定第1个元素为分界值.
    mid = my_list[start]    
    # 1.3 定义游标, 表示左边的 和 右边的数据.
    left = start
    right = end

    # 1.4 通过循环, 获取到(列表)每个数据.
    while left < right:
        # 1.5 将大于或等于分界值的数据集中到数组右边，
        while my_list[right] >= mid and left < right:
            right -= 1
        # 走这里, 说明(分界值)右边的数据比分界值小, 放左边.
        my_list[left] = my_list[right]

        # 1.6 小于分界值的数据集中到数组的左边
        while my_list[left] < mid and left < right:
            left += 1
        # 走这里, 说明(分界值)左边的数据比分界值大, 放右边.
        my_list[right] = my_list[left]

    # 1.7 循环结束后, 说明: 分界值的位置找到了.
    my_list[left] = mid

    # 1.8 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，
    # 将该部分数据分成左右两部分，同样在左边放置较小值, 右边放置较大值, 右侧的数组数据也做类似处理
    # 处理分界后, 左边的数据(即: 比分界值小的数据)
    quick_sort(my_list, start, left - 1)
    # 处理分界后, 右边的数据(即: 比分界值大的数据)
    quick_sort(my_list, right + 1, end)

# 2. 测试.
if __name__ == '__main__':
    # 2.1 定义列表
    my_list = [4, 3, 7, 1, 9, 5]
    quick_sort(my_list, 0, len(my_list) - 1)