非常全的排序总结~

稳定性： 

一个本身稳定的排序，可以实现为不稳定的排序

一个本身不稳定的排序，不可以实现为稳定的排序

判断稳定性技巧：

看在比较的过程中，是否发生了跳跃式的交换，如果发生了跳跃式的交换，那么就是不稳定的排序

一、直接插入排序

时间复杂度：两个循环O(N^2)

最好情况下时间复杂度：O(N)——>当数据有序时 对于直接插入排序来说，数据越有序，越快 

空间复杂度：没有额外的内存，只有一个tmp，O(1) 

稳定性：稳定的

思路：

public void insertSort(int[] array){
        for (int i = 1; i <array.length ; i++) {//i从1下标开始遍历
            int tmp=array[i];//每次先将i下标元素放入tmp中
            int j = i-1;
            for (; j >=0 ; j--) {//j始终等于i-1,每次往前走，找到合适的位置放tmp，知道j<0为止
                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else{
                    //array[j+1]=tmp;//找到tmp的位置就可以结束遍历了
                    break;
                }
            }
            array[j+1]=tmp;//当j<0时循环进不去，直接将tmp赋值给j+1位置
        }
    }

---

 二、希尔排序 

时间复杂度[和增量有关]：O(n^1.5~n^1.3)

空间复杂度：O(1) 

稳定性：不稳定的

思路：

//array 待排序序列 gap   组数

     public static void shell(int[]array,int gap) {//给每组数据进行希尔排序（实质上就是给每组进行直接插入排序）
        for (int i = gap; i < array.length; i++) {//与直接插入排序的区别是，i从gap开始走，每次走1步
            int tmp=array[i];
            int j=i-gap;//每次j都等于i-gap步
            for (; j>=0 ; j-=gap) {
                if(array[j]>tmp){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=tmp;//当j<0时或者array[j]<tmp时
        }

    }
    public static void shellSort(int[] array){
        int gap=array.length;//进行分组
        while(gap>1){
            shell(array,gap);//第一次分数组长度个组，每组里有一个数据，只需要将这一个数据排序，相当于什么也没干
            gap/=2;//假设第一次分为10组（每组有一个数据），第二次则分为5组（每组有2个数据，将每组里的这两个数据排序），第三次分2组（每组5个数据，将每组里的这5个数据排序）
        }
        shell(array,1);//保证最后是一组，（里面有array.length个数据，将整体排个序）
    }

---

三、直接插入排序

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

空间复杂度：O(1) 

稳定性：不稳定的

思路： 

public static void swap(int[]array,int i,int j){//交换函数
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {//j始终从i+1开始遍历
                if(array[j]<array[i]){
                    swap(array,i,j );
                }
            }
        }
    }

 优化：j再后面遍历时，找到用minIndex记录下最小值下标，将最小值下标与i下标进行交换

           会使交换的次数减少

public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;//用于存储j遍历的最小值下标，然后和i下标交换
            for (int j = i+1; j < array.length; j++) {
                if(array[j]<array[minIndex]){
                    minIndex=j;
                }
            }
            swap(array,i,minIndex);
        }
    }

---

四、堆排序 （从小到大排序）

时间复杂度：O(N)+O(N*logN)——》O(N*logN)

空间复杂度：O(1) 

稳定性：不稳定的

思路：建一个大根堆，此时0下标的值是最大的，用0下标的值和最后一个下标的值交换，              （最后一个下标用end表示），交换完之后调整0这颗树，使它仍然是大根堆，然后                  end--，继续重复上面操作，用0下标的值和end下标的值交换，调整0下标仍然为大                堆，end--，直到end减为0

public static void heapSort(int[]array){//堆排
        //1、建堆时间复杂度：O(N)
        createHeap(array);//建一个大根堆
        int end=array.length-1;
        //2、交换然后调整时间复杂度：O(N*logN)
        while(end>0){
            swap(array,0,end);//交换0下标的值和end下标的值
            shiftDown(array,0,end);//交换完之后0下标不是一个大根堆，需要重新向下调整0下标，使它变成大根堆
            end--;
        }
    }

    public static void createHeap(int[]array){//建大根堆
        for (int parent = (array.length-1-1)/2; parent >=0; parent--) {
            shiftDown(array,parent,array.length);
        }
    }


    public static void shiftDown(int[]array,int parent,int len){//向下调整
        int child=2*parent+1;
        while(chi