排序1_插入、希尔、选择排序

1. List item

1.直接插入排序(稳定)

视频演示：直接插入排序
思路：每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入（类似于搬运）。

public class Sort {
   // 直接插入排序 （升序）
    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) { //循环n-1次
            // 有序   [0, i)  假设第一个数有序
            // 无序   [i, array.length)  其余数无序
            int key = array[i]; //无序区间第一个数
            int j;
            for (j = i - 1; j >= 0; j--) { //在有序区间从后向前比较
                if (array[j] <= key) {
                    break;
                } else {
                    array[j + 1] = array[j]; //数据后移
                }
            }
            array[j + 1] = key; //插入key 排列完成
        }
    }


     //程序优化
     public static void insertSort0(int[] array) {
        for (int i = 1; i < array.length; i++) {
            // 有序   [0, i)
            // 无序   [i, array.length)
            int key = array[i];
            int j;
            for (j = i - 1; j >= 0 && array[j] > key; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = key;
        }
    }
    
    /**
     * 时间复杂度
     * 最好       平均          最坏
     * O(n)       O(n^2)        O(n^2)
     * 数据有序                 数据逆序
     * 空间复杂度
     * O(1)
     */
    public static void main(String[] args) {
        int[] a = { 2, 3, 7, 9, 4, 5, 6, 9, 1, 4, 7, 8 };
        
        int[] b = a.clone(); //clone()方法是用来复制数组
        insertSort(b);
        System.out.println(Arrays.toString(b));

        int[] c = a.clone();
        Arrays.sort(c); //直接调包 系统排序
        System.out.println(Arrays.toString(c)); 

        System.out.println(Arrays.equals(b, c)); //数组是否相等 调用Arrays.equals(b, c)
    }

}

注意

1）在有序区间从后向前判断。假设其实数据已经是升序，直接比较有序区间最后一个数，若key比有序区间最后一个数大，则不用插入；若从前向后判断，则最好情况不存在。
2）性能分析：

3）稳定。
4）插入排序元素个数少时或者元素基本有序时效率比较高。

2.希尔排序(不稳定)

视频演示：希尔排序
思路：分组插入排序
1）希尔排序是对直接插入排序的优化。
2）当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。

public class Sort {
//希尔排序 （升序）
    public static void shellSort(int[] array) {
        int gap = array.length;
        while (true) {
            gap = (gap / 3) + 1; //无论如何分组一定保证最终gap==1
            //gap = gap / 2;
            insertSortWithGap(array, gap);
            if (gap == 1) { 
                break; //排序结束gap==1 则排序结束
            }
        }
    }
    private static void insertSortWithGap(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) { //假设第一组有序
            int key = array[i];
            int j;
            for (j = i - gap; j >= 0 && array[j] > key; j -= gap) {
                array[j + gap] = array[j];
            }
            array[j + gap] = key;
        }
    }
}

注意

1）gap最终一定要可以缩减为1。
2）不稳定。
3）性能分析：

3.直接选择排序(不稳定)

图片演示：选择排序
思路：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完（类似于打擂台的方式）。

//直接选择排序 （升序）
    public static void selectSort(int[] array) { 
        // 每次选最大的放到无序区间的最后
        for (int i = 0; i < array.length - 1; i++) { //循环n-1次
            // 无序 [0, array.length - i)
            // 有序 [array.length - i, array.length)
            int maxIndex = 0; //假设最大数下标0
            for (int j = 1; j < array.length - i; j++) { //从下标为1的数开始比较
                if (array[j] > array[maxIndex]) {
                    maxIndex = j; //maxIndex记录真正最大数的下标
                }
            }
            swap(array, maxIndex, array.length - i - 1); //放到无序区间最后
        }
    }
    
//直接选择排序 （降序）
    public static void selectSort0(int[] array) {
        // 每次选最小的放到无序区间的最开始
        for (int i = 0; i < array.length - 1; i++) {
            // 无序区间 [i, array.length)
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }

            swap(array, minIndex, i);
        }
    }
    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

注意

1）直接选择排序是数据不敏感型排序 ——原始数据顺序对选择排序顺序没有影响。
2）不稳定
3）性能分析：

双向选择排序

思路：每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完 。

//双向选择排序
public static void selectSort2(int[] array) {
        // 无序: [begin, end]
        int begin = 0;
        int end = array.length - 1;

        while (begin < end) { //长度小于等于1就可以停止
            int minIndex = begin;
            int maxIndex = begin;
            for (int j = begin + 1; j <= end; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }
            swap(array, minIndex, begin);
            //最大数刚好就在begin位置 需特殊处理
            if (maxIndex == begin) { //最大数下标发生变化
                maxIndex = minIndex;
            }
            swap(array, maxIndex, end); 
            begin++; end--;
        }
    }
     private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

注意：

array = { 9, 5, 2, 7, 3, 6, 8 }; // 交换之前
// low = 0; high = 6
// max = 0; min = 2
array = { 2, 5, 9, 7, 3, 6, 8 }; // 将最小的交换到无序区间的最开始后
// max = 0，但实际上最大的数已经不在 0 位置，而是被交换到 min 即 2 位置了
// 所以需要让 max = min 即 max = 2
array = { 2, 5, 8, 7, 3, 6, 9 }; // 将最大的交换到无序区间的最结尾后