选择排序、插入排序、希尔排序(是第一个突破 O(n²) 的排序算法)

1、选择排序

选择排序
选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想就是，每一趟 n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列的第 i 个记录。
算法步骤
简单选择排序：
1、在未排序序列中找到最小（大）元素，存放到排序序列的起始位置;
2、在剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾;
3、重复步骤2，直到所有元素排序完毕。

代码：

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
selectionSort(arr)
print("排序后的数组:")
for i in range(len(arr)):
    print("%d" %arr[i])

算法分析：
选择排序是不稳定排序，时间复杂度固定为 O(n²)，因此它不适用于数据规模较大的序列。不过它也有优点，就是不占用额外的内存空间。

2、插入排序

直接插入排序（Straight Insertion Sort），是一种简单直观的排序算法，它的基本操作是不断地将尚未排好序的数插入到已经排好序的部分，好比打扑克牌时一张张抓牌的动作。
在冒泡排序中，经过每一轮的排序处理后，序列后端的数是排好序的；而对于插入排序来说，经过每一轮的排序处理后，序列前端的数都是排好序的。

基本思想
先将第一个元素视为一个有序子序列，然后从第二个元素起逐个进行插入，直至整个序列变成元素非递减有序序列为止。
如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入大相等元素的后面。整个排序过程进行 n-1 趟插入。

代码：

def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
insertionSort(arr)
print("排序后的数组:")
for i in range(len(arr)):
    print("%d" %arr[i])

算法分析
插入排序是稳定排序，平均时间复杂度为 O(n²)，空间复杂度为 O(1)。

3、希尔排序

希尔排序（Shell’s Sort）是第一个突破 O(n²) 的排序算法，是直接插入排序的改进版，又称“缩小增量排序”（Diminishing Increment Sort）。它与直接插入排序不同之处在于，它会优先比较距离较远的元素。
**基本思想:**先将整个待排序列分割成若干个字序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
子序列的构成不是简单地“逐段分割”，将相隔某个增量的记录组成一个子序列，让增量逐趟缩短，直到增量为 1 为止。

def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr
arr = [64, 34, 25, 12, 22, 11, 90]
shellSort(arr)
print("排序后的数组:")
for i in range(len(arr)):
    print("%d" %arr[i])

算法分析：
希尔排序是不稳定排序，它的分析是一个复杂的问题，因为它的运行时间依赖于增量序列的选择，
它的平均时间复杂度为O(n^1.3)，最好情况是 O(n)，最差情况是 O(n²)。空间复杂度为 O(1)。

参考：https://github.com/fiteen/Sorting-Algorithm.