Java 中的插入排序和希尔排序

插入排序

时间复杂度：O(N^2)

空间复杂度：O(1)

稳定性：稳定排序

先设置一个 bound，bound = 0；

[0,bound)已排序区间

[bound,size)待排序区间

先取 bound 位置的元素，往前面的已排序期间中插入，插入完毕后已排序区间仍然是有序的，把 bound 位置的元素在前面找到一个合适的位置，同时需要搬运相关的元素

 public static void insertSort(int[] array){
        //通过 bound 来划分两个区间,[0,bound)已排序区间，[bound,size)待排序区间

        for (int bound = 1;bound < array.length;bound++){
            int v = array[bound];
            int cur = bound - 1;
            while (cur >= 0){
                if (array[cur] > v){
                    array[cur + 1] = array[cur];
                }else {
                    break;
                }
                cur--;
            }
            //当退出循环的时候，cur 走到了 cur - 1 的位置所以 cur 需要 + 1
            array[cur + 1] = v;
        }
    }

 

 

希尔排序

时间复杂度：O(N^1.3)【理论上】

空间复杂度：O(1)

稳定性：不稳定排序

进阶版本的插入排序，先分组，针对每个组进行插入排序，逐渐缩小组的个数，最终整个数组就接近有序了

 

当 gap 比较大的时候，分的组数比较多每个组的元素个数就少，此时插排效率很高

当 gap 比较小的时候，分得到组数少，每个组的元素个数也就多了。此时整个数组已经接近有序了，此时的插排效率也很高

从数学上可以证明，希尔排序效率可以比插排排序更高，gap 序列不能随便乱选，理论上，通过合理选择希尔排序中的 gap 序列，希尔排序的时间复杂度可以达到O(N^1.3)

实现希尔排序的时候，使用 size/2， size/4, size/8...1希尔序列O(N^2)

public static void shellSort(int[] array){
        int gap = array.length / 2;
        while (gap > 1){
            // 需要循环进行分组插排
            insertSortGap(array,gap);
            gap = gap / 2;
        }
        insertSortGap(array,1);
    }

    private static void insertSortGap(int[] array, int gap) {

        //当 gap 替换成 1 的时候，理论上这个代码就和插入排序一模一样
        for (int bound = gap;bound < array.length;bound++){
            int v = array[bound];
            int cur = bound - gap;//找到同组中的上一个元素
            while (cur >= 0){
                if (array[cur] > v){
                    array[cur + gap] = array[cur];
                }else {
                    break;
                }
                cur -= gap;//找同组的相邻元素，同组中的下标差值就是 gap
            }
            //当退出循环的时候，cur 走到了 cur - 1 的位置所以 cur 需要 + 1
            array[cur + gap] = v;
        }
    }