排序算法

一、冒泡排序

重复比较相邻的元素。如果第一个比第二个大，就交换他们两个

def bubble_sort(arr):
    # 获取数组的长度
    n = len(arr)
    # 遍历数组进行数组的排序
    for i in range(n):
        for j in range(n - 1): #循环n-1次
            if arr[j] > arr[j + 1]:
                temp = arr[j + 1]  # 前一个比后一个大，则前一个跟后一个对换，知道换到最后一个
                arr[j + 1] = arr[j]
                arr[j] = temp
    return arr

arr = [10, 9, 6, 5, 8, 7, 4, 3, 2, 1]
sort_arr = bubble_sort(arr)
print("排序后的结果:{}".format(sort_arr))

二、选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

def selection_sort(arr):
    """
    选择排序
    :param arr:
    :return:
    """
    # 获取数组的长度
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i + 1, n):  # 遍历后面的数
            if arr[j] < arr[min_index]:
                # 只要有比他小的就把下标赋值给min_index
                min_index = j
        # 把最小的数跟当前的位置的数位置互换
        temp = arr[i]
        arr[i] = arr[min_index]
        arr[min_index] = temp
    return arr


arr = [3, 1, 10, 9, 8, 7, 6, 2, 5, 4]
sort_arr = selection_sort(arr)
print("排序后的结果:{}".format(sort_arr))

3，插入排序

要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O()。

def insertion_sort(arr):
    """
    插入排序
    :param arr:
    :return:
    """
    n = len(arr)
    print(arr)
    # 遍历数组进行数组的排序
    for i in range(1, n):
        pre_index = i - 1
        current = arr[i]
        findIndex = i
        # 和之前的有序序列进行比较，当前值小于前一个值当前值跟前一个值替换，知道当前值是最小的
        '''
        [3, 10, 1]
        [1, 3, 10] arr2=arr1 arr1=arr0 逐个替换，租后剩下finindex==0,current插入到找到的位置,并替换找到的位置让arr[findIndex] = current即可
        '''
        while current < arr[pre_index] and pre_index >= 0:
            arr[pre_index + 1] = arr[pre_index]  # 替换前一个值
            findIndex = pre_index
            pre_index -= 1  # 索引下标往前移动，继续循环比较
        # 将current插入到找到的位置,并替换找到的位置
        arr[findIndex] = current
        print(arr)
    return arr


arr = [10, 3, 1, 9, 8, 7, 6, 2, 5, 4]
sort_arr = insertion_sort(arr)
print("排序后的结果:{}".format(sort_arr))

[10, 3, 1, 9, 8, 7, 6, 2, 5, 4]
[3, 10, 1, 9, 8, 7, 6, 2, 5, 4]
[1, 3, 10, 9, 8, 7, 6, 2, 5, 4]
[1, 3, 9, 10, 8, 7, 6, 2, 5, 4]
[1, 3, 8, 9, 10, 7, 6, 2, 5, 4]
[1, 3, 7, 8, 9, 10, 6, 2, 5, 4]
[1, 3, 6, 7, 8, 9, 10, 2, 5, 4]
[1, 2, 3, 6, 7, 8, 9, 10, 5, 4]
[1, 2, 3, 5, 6, 7, 8, 9, 10, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
排序后的结果:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4，希尔排序

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”，是直接插入排序算法的一种更高效的改进版本

def shell_sort(arr):
    # 获取数组的长度
    n = len(arr)
    # 计算步长
    gap = 1 * 3 + 2
    # 遍历进行更新操作
    while gap > 0:
        # 遍历数组进行数组的排序
        for i in range(gap, n):
            # 之前后续序列部分的最后一个值的索引位置
            '''
            将全部元素分成小于n的子序列，在子序列中分别执行插入排序
            
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
            [5, 9, 8, 7, 6, 10, 4, 3, 2, 1]  比较坐标0,5/1,6 .../4,9  比较大小，交换顺序。
            '''
            pre_index = i - gap
            # 当前值
            current = arr[i]
            # 和之前的有序序列进行比较，找到比当前值小的那个位置
            print(arr)
            while arr[pre_index] > current and pre_index >= 0:
                # 将大于current的数据往后移动
                arr[pre_index + gap] = arr[pre_index]
                # print(pre_index + gap)
                # print(pre_index)
                # 索引下标往前移动，继续比较
                pre_index -= gap
            # 将current插入到找到的位置
            arr[pre_index + gap] = current
        gap = gap // 3 #缩小增量，缩小步长
    return arr



arr = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
sort_arr = shell_sort(arr)
print("排序后的结果:{}".format(sort_arr))


[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]  
[5, 9, 8, 7, 6, 10, 4, 3, 2, 1]  #0 5
[5, 4, 8, 7, 6, 10, 9, 3, 2, 1]
[5, 4, 3, 7, 6, 10, 9, 8, 2, 1]
[5, 4, 3, 2, 6, 10, 9, 8, 7, 1]
[5, 4, 3, 2, 1, 10, 9, 8, 7, 6]
[4, 5, 3, 2, 1, 10, 9, 8, 7, 6]
[3, 4, 5, 2, 1, 10, 9, 8, 7, 6]  # 21  10  [4,5,3..]=>21->[4,3,5..]=>10=>[3,4,5..]
[2, 3, 4, 5, 1, 10, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 10, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 10, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 9, 10, 8, 7, 6]
[1, 2, 3, 4, 5, 8, 9, 10, 7, 6]
[1, 2, 3, 4, 5, 7, 8, 9, 10, 6]
排序后的结果:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]