排序【2.1】插入排序(InsertSort && ShellSort)

1、插入排序——直接插入排序（Straight Insertion Sort）

（1）基本思想：

像排序一手扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。如图所示，左手上的牌总是排序好的，原来这些牌是在桌子上排堆中顶部的牌。

基本思想：
把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

（2）排序过程：

下面选取直接插入排序的一个中间过程对其进行说明。假设{20,30,40,10,60,50}中的前3个数已经排列过，是有序的了；接下来对10进行排列。示意图如下：

图中将数列分为有序区和无序区。我们需要做的工作只有两个：
(1)取出无序区中的第1个数，并找出它在有序区对应的位置。
(2)将无序区的数据插入到有序区；若有必要的话，则对有序区中的相关数据进行移位。

（3）时间复杂度：

直接插入排序的时间复杂度是$O(N^2)$。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，直接插入排序的时间复杂度是$O(N^2)$。
--------------------------------------------------------------------------------
最佳情况：O（n），其中输入数组已排好序
最坏情况：O（n^2），其中输入数组已反向排好序
平均情况：O（n^2）
--------------------------------------------------------------------------------

（4）稳定性：

直接插入排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 – 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

---

2、插入排序——希尔排序（Shell Sort）

（1）基本思想：

希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

（2）排序过程：

以数列{80,30,60,40,20,10,50,70}为例，演示它的希尔排序过程。
第1趟：(gap=4)

当gap=4时,意味着将数列分为4个组： {80,20},{30,10},{60,50},{40,70}。
对应数列： {80,30,60,40,20,10,50,70}
对这4个组分别进行排序，排序结果： {20,80},{10,30},{50,60},{40,70}。
对应数列： {20,10,50,40,80,30,60,70}

第2趟：(gap=2)

当gap=2时,意味着将数列分为2个组：{20,50,80,60}, {10,40,30,70}。 对应数列： {20,10,50,40,80,30,60,70}
注意：{20,50,80,60}实际上有两个有序的数列{20,80}和{50,60}组成。
{10,40,30,70}实际上有两个有序的数列{10,30}和{40,70}组成。
对这2个组分别进行排序，排序结果：{20,50,60,80}, {10,30,40,70}。 对应数列： {20,10,50,30,60,40,80,70}

第3趟：(gap=1)

当gap=1时,意味着将数列分为1个组：{20,10,50,30,60,40,80,70}
注意：{20,10,50,30,60,40,80,70}实际上有两个有序的数列{20,50,60,80}和{10,30,40,70}组成。
对这1个组分别进行排序，排序结果：{10,20,30,40,50,60,70,80}

（4）时间复杂度：

希尔排序的时间复杂度与增量(即，步长gap)的选取有关。例如，当增量为1时，希尔排序退化成了直接插入排序，此时的时间复杂度为O(N²)，而Hibbard增量的希尔排序的时间复杂度为O(N3/2)。

（5）稳定性：

希尔排序是不稳定的算法，它满足稳定算法的定义。对于相同的两个数，可能由于分在不同的组中而导致它们的顺序发生变化。

---

3、算法实现（python3）

"""
插入排序：

基本思想：
把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，
排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

时间复杂度：O(n^2)
"""

def insertSort(num_list, num_len):
    for i in range(num_len):      # O(n)
        key = num_list[i]
        j = i - 1
        while j >= 0 and num_list[j] > key:      # O(n)
            num_list[j + 1] = num_list[j]
            j -= 1
        num_list[j + 1] = key
    return num_list


"""
希尔排序：

基本思想：
希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，
所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。
然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

时间复杂度：O(n^3/2)
"""

def shellSort(num_list, num_len):
    gap =  num_len // 2
    while gap > 0:
        for i in range(gap):
            for j in range(i+gap, num_len, gap):
                if num_list[j] < num_list[j-gap]:
                    key = num_list[j]
                    k = j-gap
                    while k >= 0 and num_list[k] > key:
                        num_list[k + gap] = num_list[k]
                        k -= gap
                    num_list[k + gap] = key
        gap //= 2
    return num_list


if __name__ == '__main__':
    num_list = [20, 40, 30, 10, 60, 50]
    num_len = len(num_list)
    print("before sort:", num_list)

    # num_order = insertSort(num_list, num_len)
    num_order = shellSort(num_list, num_len)

    print("after sort:", num_order)

运行结果：

before sort: [20, 40, 30, 10, 60, 50]
after sort: [10, 20, 30, 40, 50, 60]