排序（1）

排序是数据结构中的一个大板块，现在将排序进行一个系统的举例。
插入排序

插入排序是从整个数组的第二个数开始，划分区间，第二个数及之后是无序区间，排一次序无序区间减少一次，然后每次用无序区间的第一个数和之前的有序区间进行比较，如果小于有序区间的最后一个数，把有序区间这个数往后移一位，继续比较，如果还小，继续后移。一次插入完成之后，把key放到空位置。
先来看代码：

  public static void insertSort0(int[] array) {
        for(int i=1;i<array.length;i++){
            int key=array[i];
            int j=i-1;
            for(;j>=0&&array[j]>key;j--){
                array[j+1]=array[j];
            }
            array[j+1]=key;
        }
        //最好   O（n）
        //最坏O（n^2)
    }

希尔排序
原理：
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所
有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1
时，所有记录在统一组内排好序。

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
   快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
   过程：
   

代码如下：

 public static void shellSort(int[] array) {
        int gap = array.length;
        while (true) {
            gap = (gap / 3) + 1;
            insertWithGap(array, gap);
            if (gap == 1) {
                break;
            }
        }
    }

    private static void insertWithGap(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int key = array[i];
            int j = i - gap;
            for (; j > 0 && array[j] > key; j--) {
                array[j + gap] = array[j];
            }
            array[j + gap] = key;
        }
    }

选择排序
原理：
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。重点在于划分无序区间

  public static void select(int[] array) {
       for(int i=0;i<array.length-1;i++){
           int max=0;
           for(int j=1;j<array.length-i;j++){
           //  无序区间 [0,array.length-i)
               if(array[j]>array[max]){
                   max=j;
               }
           }
           swap(array,max,array.length-i-1);
       }
    }

    public static void selectsmall(int[] array) {
        // 无序区间[i,array.length)
       for(int i=0;i<array.length-1;i++){
           int min=i;
           for(int j=i+1;j<array.length;j++){
               if(array[j]<array[min]){
                   min=j;
               }
           }
           swap(array,min,i);
       }
    }

堆排序
是利用堆的特性进行选择排序，即先建一个大堆，把堆的第一个元素和无序区间进行交换，交换之后再进行一次调整，继续交换。

 public static void heapSort(int[] array) {
        createHeapBig(array, array.length);
        for (int i = 0; i < array.length - 1; i++) {
            swap(array, 0, array.length - i - 1);
            shiftDownBig(array, 0, array.length - 1 - i);
        }
    }

    public static void createHeapBig(int[] a, int s) {
        for (int i = (s - 2) / 2; i >= 0; i--) {
            shiftDownBig(a, i, s);
        }
    }

    private static void shiftDownBig(int[] array, int index, int size) {
        while (2 * index + 1 < size) {
            int max = 2 * index + 1;
            if (max + 1 < size && array[max + 1] > array[max]) {
                max = max + 1;
            }
            if (array[index] >= array[max]) {
                return;
            }
            swap(array, index, max);
            index = max;
        }
    }

冒泡排序
之前的博客中讲到了
https://blog.csdn.net/shoushou_/article/details/96481323