插入排序

概念：
插入排序是一种简单直观的排序方法，其基本思想在于每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成。
由插入排序的思想可以引申出三个重要的排序算法：直接插入排序，折半插入排序和希尔排序。

1. 直接插入排序

思想：为了实现对L[1…n]的排序，可以将L(2)~L(n)依次插入到前面已经排好序的子序列中，初始假定L(1)是一个已经排好序的子序列。上述操作执行n-1次后就能得到一个有序表。插入爱旭在是现场通常采用就地排序(空间复杂度为O(1))，因而再从后往前的比较过程中，需要反复把一排好序的元素逐步向后挪威，为新元素提供插入空间。

• java代码实现：

import java.util.Arrays;

/**
 * @author：cch
 * @description：直接插入排序
 * @date 2020/12/15
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] numberArr = new int[] {3,1,8,9,0,23,7};
        // 从第二个数开始
        for (int i = 1; i < numberArr.length; i ++) {
            // 待插入数据
            int insertValue = numberArr[i];
            // 前一位置作为索引
            int insertIndex = i - 1;
            // 索引值大于等于0，防止越界，同时索引位置数据大于待插入数据，索引位置数据后移，同时索引迁移
            while (insertIndex >= 0 && insertValue < numberArr[insertIndex]) {
                numberArr[insertIndex + 1] = numberArr[insertIndex];
                insertIndex --;
            }
            // 待插入数据归位
            numberArr[insertIndex + 1] = insertValue;
        }
        System.out.println(Arrays.toString(numberArr));
    }
}

• 性能分析：
  空间效率：仅使用了常数个辅助单元，因而空间复杂度为O(1)。
  时间效率：在排序过程中，向有序子表中逐个地插入元素的操作进行了n-1趟，每趟操作都分为比较关键字和移动元素，而比较次数和一动次数取决于待排序表的初始状态。
  最好的情况：表中的元素已经有序，此时没插入一个元素，都只需要比较一次而不用移动元素，因而时间复杂度为O(n)。
  最坏的情况：表中元素的顺序刚好与排序结果中元素相反(逆序)时，总的比较次数最大。
• 稳定性
  由于没每次插入元素时是从后往前先比较在移动，所以不会出现相同元素相应位置发生变化的情况，即直接插入排序是一个稳定的排序方法。
• 适用性
  直接插入排序算法适用于顺序存储和链式存储的线性表。党委链式存储时，可以从前往后查找指定元素的位置。注意：大部分排序算法都仅适用于顺序存储的线性表。

2. 折半插入排序

思想：从前面的直接插入排序算法中，不难看出每趟插入的过程中，都进行了两项工作：
①从前面的子表中查找处待插入元素应该被插入的位置；
②给插入为止腾出空间，将待插入元素复制到表中的插入位置。
注意到该算法中，总是边比较边移动元素，下面将比较合移动的操作分离出来，即先折半查找出元素待插入的位置，然后再统一地移动带插入位置之后的所有元素。当排序表为顺序存储的线性表时，可以对直接插入排序算法做如下改进：

• java代码实现：

/**
 * @author：cch
 * @description：折半查找
 * @date 2020/12/15
 */
public class BinarySearch {
    public static void main(String[] args) {
        BinarySearch binarySearch = new BinarySearch();
        int[] arr = {1,3,6,9,12,23,33,44,45,67,78,98,100,111,123,1234,2345,9999,11111,12345,666666,900000};
        int res = binarySearch.binarySearch(arr, 44);
        System.out.println("res=" + res);
    }

    /**
     * 二分查找
     * @param arr 要进行查找的数组，要求数组必须是有序的
     * @param findElem 要查找的元素
     * @return 返回要查找的元素在数组的索引位置， 返回-1表示没找到
     */
    public int binarySearch(int[] arr, int findElem) {
        int low = 0;
        int high = arr.length - 1;
        int mid;
        while (low <= high) {
            mid = (low + high) / 2;
            //如果要查找的元素findElem小于中间位置的元素mid，指向数组的较大端的high索引重新指向中间索引mid的左边（mid-1）
            if (findElem < arr[mid]) {
                high = mid - 1;
            }
            //如果要查找的元素findElem大于中间位置的元素mid，指向数组的较小端的low索引重新指向中间索引mid的右边（mid+1）
            if (findElem > arr[mid]) {
                low = mid + 1;
            }
            if (arr[mid] == findElem) {
                return mid;
            }
        }
        return -1;
    }
}

• 总结：
• 从上述算法中，不难看出折半插入排序仅仅是减少了比较元素的次数，该比较次数与待排序表的初始状态无关，仅取决于表中的元素个数n；而元素的一动次数没有改变，它依赖于待排序表的初始状态。时间复杂度为O(n^2)。折半插入排序是一个稳定的排序算法。

3. 希尔排序

从前面的讲解不难看出，直接插入排序算法适用于基本有序的排序表和数量不大的排序表。基于这两点，1959年D.L.Shell提出了希尔排序，又称为缩小增量排序。
希尔排序的基本思想是：先将待排序的表分割成若干个形如L[i，i+d，i+2d，…i+kd]的“特殊”字表，分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。

例如，假设有这样一组数[ 12 15 80 12 90 23 13 80 26 25 14 40 21 3 35]。如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样(竖着的元素是步长组成)：

12 15 80 12 90
23 13 80 26 21
14 40 25 3  35

然后我们对每列进行排序：

12 13 25 3 21
14 15 80 12 35
23 40 80 26 90
45 

将上述四行数字，依序接在一起时我们得到：[ 12 13 25 3 21 14 15 80 12 35 23 40 80 26 90 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：

12 13 25
3  21 14
15 80 12
35 23 40
80 26 90
45

排序之后变为：

3 13 12
12 15 14
15 23 25
35 26 40
45 80 90
80

最后以1步长进行排序（此时就是简单的插入排序了）

3 12 12 13 14 15 21 23 25 26 35 40 45 80 80 90

• java代码实现：

/**
 * @author：cch
 * @description：希尔排序
 * @date 2020/12/15
 */
public class ShellSort {
    public static void main(String[] args)
    {
        int[] ins = {12,15,80,12,90,23,13,80,26,25,14,40,21,3,35};
        int[] ins2 = sort(ins);
        for(int in: ins2){
            System.out.println(in);
        }
    }
    public static int[] sort(int[] ins){

        int n = ins.length;
        int gap = n/2;
        while(gap > 0){
            for(int j = gap; j < n; j++){
                int i=j;
                while(i >= gap && ins[i-gap] > ins[i]){
                    int temp = ins[i-gap]+ins[i];
                    ins[i-gap] = temp-ins[i-gap];
                    ins[i] = temp-ins[i-gap];
                    i -= gap;
                }
            }
            gap = gap/2;
        }
        return ins;
    }
}

• 性能分析：
  空间效率：仅使用了常熟个辅助单元，因而空间复杂度为O(1)
  时间效率：当n在某个特定范围时，西尔艾徐的时间复杂度约为O(n^{1.3)，最坏的情况下希尔爱虚的时间复杂度为O(n}2)。
• 稳定性：当相同官架子的记录被划分到不同的子表时，可能会改变他们之前的相对次序，因此，希尔排序是一个不稳定的排序方法。
• 适用性：希尔排序算法仅适用于当线性表为顺序存储的情况。