插入排序、希尔排序、直接选择排序、堆排序

本文主要内容：
1.插入排序
2.希尔排序
3.直接选择排序
4.堆排序

1.排序：默认情况下为非降序排序
2.稳定性：能够保证排序过程中相同的数据排序前后相对位置不变
3.插入排序：减治算法排序
每次从无序区间选择第一个数插入到有序区间的合适位置（打牌）
时间复杂度：最坏o(n的平方)：完全逆序 最好o(n)：完全有序[从后往前找]
一般情况：o(n的平方)
越接近有序，执行时间效率越高
空间复杂度：o(1)
稳定性：稳定
计时：long begin = System.naoTime ();long end = System.naoTime ();
System.out.println(end-begin);
4.希尔排序（Shell Sort）:分组进行插入排序
分组越多：大数据可以很快走到最后，每次分组排序后，数据不太有序
分组越少：每次分组排序后，数据更有序
size = 10;gap = size;
gap = gap/3+1;[4,2,1]
gap = gap/2;[5,2,1]
前提：利用插入排序中，数据越接近有序，时间效率越高。在插入排序之前做预排序（分组插排），使数据尽可能接近有序。
如何分组：一开始分很多组，越来越少
时间复杂度：最好：o(n) 平均：O(n^1.3,n1.4) 最坏：O(n^2)
空间复杂度：O(1)
稳定性：不稳定（相等的两个数被分到了两个不同的组）
在插排中还有折半插排
5.直接选择排序：减治算法
选择排序：每次遍历无序区间（直接遍历/利用堆），找到无序区间的最大的数，把最大的数放在无序区间的最后，一直选择n-1数之后，数据完全有序
时间复杂度：o(n^2)
空间复杂度：O(1)
稳定性：不稳定 例如：9 5 2 3 5
6.堆排序：首先将现有的元素建大堆，然后将最大的元素与最后的元素交换，将堆进行向下调整，选出第二大元素与末尾元素交换，向下调整一直循环下去。
堆排的时间复杂度：o(n*nlog(n))
空间复杂度：o(1)
稳定性：不稳定
选择排序选最大的数，选最小的可以吗？
选择排序也可以，同时选最大和最小
堆排往往建大堆，小堆更复杂，效率更低

public class Solution3 {
    //创建一个随机数组
    public static int[] createArray(){
        Random random = new Random(135531);
        int[] array = new int[10];
        for(int i = 0;i<array.length;i++){
            int a = random.nextInt(100);
            array[i] = a;
        }
        return array;
    }
    //打印数组
    public static void showArray(int[] array){
        for(int i =0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
    //插入排序：时间复杂度：o(n^2) 空间复杂度：o(1) 是稳定的
    //给定一组数，假设前面的部分是有序的，后面的部分是无序的，从无序的部分找一个元素插入到有序的部分，直到全部有序
    //起初有序部分只有第一个数，后面都是无序部分
    //假如有n个数，默认第一个数有序，则外层循环可以循环n-1次
    public static void insertSort(int[] array){
        for(int i = 0;i<array.length-1;i++){
            //有序：[0,i],无序：[i+1,array.length)
            int key = array[i+1];//待插入元素
            //从后往前遍历有序部分，找到合适的位置，后面的元素往后挪动一位，最后插入元素
            int j = 0;
            for(j = i;j>=0;j--){
                if(key>=array[j]){
                    break;
                }
                array[j+1] = array[j];//即j下标以后的元素均往后移动一位
            }
            array[j+1] = key;
        }
    }
    public static void insertSort1(int[] array){
        for(int i = 1;i<array.length;i++){
            //有序：[0,i),无序：[i,array.length)
            int key = array[i];
            int j = 0;
            for(j = i-1;j>=0;j--){
                if(key>=array[j]){
                    break;
                }
                array[j+1] = array[j];
            }
            array[j+1] = key;
        }
    }

    //希尔排序：时间复杂度为O(n^1.3-n^1.4) 空间复杂度为：O(1) 不稳定
    //将现有的元素按照一定的公式进行分组，将各个组内元素进行插入排序(预排序)
    //最后当分组为1时，插入排序，终止
    //公式为：[(array.length)/3]+1
    public static void insertSortWithGap(int[] array,int gap){
        //当gap为1时，就是插入排序
        //假设有十个数进行希尔排序，前四个元素可以看成有序的，所以只需要循环六次即可，即array.length-gap次
        for(int i = 0;i<array.length-gap;i++){
            int key = array[i+gap];
            int j = 0;
            for(j=i;j>=0;j = 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;
            insertSortWithGap(array,gap);
            if(gap==1){
                return;
            }
        }
    }
    //直接选择排序:时间复杂度为o(n^2),空间复杂度为O(1),不稳定
    //给定一组无序的数，假设前面的数是无序的，后面的数是有序的，在无序部分找到最大的数与无序部分的最后一个元素进行交换，直到有序
    //起初有序部分为0，无序部分为所有元素
    //假设有n个数，选择排序直到后n-1个元素有序，就默认整个数组有序，即循环n-1次
    public static void swap(int[] array,int a,int b){
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    public static void selectSort(int[] array){
        for(int i = 0;i<array.length-1;i++){
            //无序：[0,array.length-i) 有序：[array.length-i,array.length)
            int max = 0;
            for(int j = 1;j<array.length-i;j++){
                if(array[max]<array[j]){
                    max = j;
                }
            }
            swap(array,max,array.length-i-1);
        }
    }
    //堆排序
    //给定一组数据，将这组数据建成大堆，将最大的元素与最后一个元素交换后，删除最后一个元素。
    //继续向下调整，找到第二大，继续交换，一次循环，直到排序完成
    //开始时无序部分是[0,array.length-i)，建堆后，当最大元素与最后元素交换后，无序部分的元素为：[0,array.length-i-1)
    public static void heapify(int[] array,int size,int index){
        //向下调整
        //首先应该考虑index是否为叶子结点，如果不是，则需要考虑index结点是否有右孩子
        // 如果有右孩子，则将左右孩子中最大的结点与index节点比较，如果孩子结点较大，则进行交换，然后继续向下调整
        while (true) {
            int left = 2 * index + 1;
            if (left >= size) {
                return;
            }
            int max = left;
            int right = left + 1;
            if (right < size && array[max] < array[right]) {
                max = right;
            }
            if (array[max] <= array[index]) {
                return;
            }
            swap(array, max, index);//java中值传递
            index = max;
        }
    }
    public static void createHeap(int[] array){
        //建大堆
        //从最后一个结点的父节点往前遍历，依次做向下调整
        for(int i = (array.length-2)/2;i>=0;i--){
            heapify(array,array.length,i);
        }
    }
    public static void heapSort(int[] array){
        createHeap(array);
        //因为已经建大堆，即最大元素已知，假设有n个元素，只需要循环n-1次
        for(int i = 0;i<array.length-1;i++){
            swap(array,0,array.length-i-1);
            heapify(array,array.length-i-1,0);
        }
    }

    public static void main(String[] args) {
        int[] a = createArray();
        showArray(a);
        insertSort(a);
        showArray(a);
        insertSort1(a);
        showArray(a);
        System.out.println("==========================");
        shellSort(a);
        showArray(a);
        System.out.println("==========================");
        selectSort(a);
        showArray(a);
        System.out.println("==========================");
        heapSort(a);
        showArray(a);
    }
}

//运行结果：
39 91 83 19 40 0 11 61 51 73 
0 11 19 39 40 51 61 73 83 91 
0 11 19 39 40 51 61 73 83 91 
==========================
0 11 19 39 40 51 61 73 83 91 
==========================
0 11 19 39 40 51 61 73 83 91 
==========================
0 11 19 39 40 51 61 73 83 91