排序，java代码实现（上）

七大基于比较的排序

7大排序分别为：
1.插入排序
2.希尔排序
3.选择排序
4.堆排序
5.冒泡排序
6.快速排序
7.归并排序

这7种排序都属于 In-Place 类型，即为原地排序

插入排序：
减治算法排序
每次从无序期间选择第一个数，插入到有序区间的合适位置
过程：
每次把无序区的第一个数，在有序区遍历，找到合适位置，搬移原有数据

时间复杂度：最好O（n） 最坏O（n²） 平均O（n²）
空间复杂度：O（1）
稳定性：稳定

注：稳定性：能保证排序过程中相等的数据的相对顺序不变
插入排序，越接近有序，执行时间效率越高

代码实现：

public static void insertSort(int[] array) {//插入排序
        for (int i = 0; i < array.length - 1; i++) {
            //有序区间  [0,i]
            //无序区间  [i+1,array.length]
            //待插入的数据    array[i+1]
            int j;
            int key = array[i + 1];
            for (j = i; j >= 0; j--) {
                if (key >= array[j]) {
                    break;
                }
                array[j + 1] = array[j];//搬移，将插入位置空出来
            }
            array[j + 1] = key;
        }
    }

希尔排序：
前提：利用插入排序中，数据越接近有序，时间效率越高
在插入排序之前做好预分组（分组插排），让数据尽可能有序
动态分组：一开始分很多，然后越来越少

时间复杂度：
最好o(n) 平均O(n^1.3-1.4) 最坏O（n^2）
空间复杂度： O(1)
稳定性：不稳定（相等的数不一定放在同一组中）

代码实现：

 private static void insertSortGap(int[]array,int gap){//希尔排序中用到的插入排序
        for (int i = 0; i < array.length - gap; i++) {

            int j;
            int key = array[i + gap];
            for (j = i; j >= 0; j-=gap) {
                if (key >= array[j]) {
                    break;
                }
                array[j + gap] = array[j];//搬移，将插入位置空出来
            }
            array[j + gap] = key;
        }
    }

    public static void shellSort(int[] array){//希尔排序主体部分
        int gap = array.length;
        while(true){
            gap=gap/3 +1;
            insertSortGap(array,gap);
            if (gap==1){
                return;
            }

        }
    }

选择排序（直接选择排序/堆排序）

每次遍历无序区间，找到无序区间的最大数
把最大数放到无序区间的左后门
一直选择 n - 1（n）数之后，数据完全有序

时间复杂度O(n^2) 数据不敏感
空间复杂度O(1)
稳定性：不稳定

代码实现：

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

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

堆排序
运用堆的思想，按照大堆，堆数组进行排序

时间复杂度：O（n*log(n)） 数据不敏感
空间复杂度：O（1）
稳定性： 不稳定

代码实现：

 public static void heapify(int[] array,int size, int index) {
        while (true) {
            int left = index * 2 + 1;
            if (left >= size) {
                return;
            }

            int max = left;
            if (left + 1 < size && array[left + 1] > array[left]) {
                max = left + 1;
            }
            if (array[index] >= array[max]) {
                return;
            }

            swap(array, index, max);
            return;
        }
    }

    public static void createHeap(int[] array, int size){
        //parent = （child-1）/2
        for(int i =(size-2)/2;i>=0;i--){
            heapify(array,size,i);
        }
    }

    public static void heapSort(int[] array){//主体部分
        createHeap(array,array.length);
        for (int i = 0;i<array.length - 1;i++){
            swap(array,0,array.length-i-1);
            heapify(array,array.length-i-1,0);
        }
    }