七种常用排序总结(插排，希尔， 选择， 冒泡，快排，堆排，归并)

一.插入排序 

从第二个数字开始记录，比较前i个数字，超过记录的数字则后移，使得前i个数字有序。

   /*
    * 插入排序
    * 空间复杂度O(1)
    * 时间复杂度O(n^2)
    * 稳定
    */
    public static void insertSort(int[] array){
        for(int i = 1 ; i < array.length ; i++){
            int temp = array[i];
            int j = i-1;
            for(; j >= 0 ;j-- ) {
                if (array[j] > temp) {
                    array[j + 1] = array[j];
                } else {
                    break;
                }
            }
            array[j+1] = temp;
        }
    }

二.希尔排序

设置一个增量值 ，把数据按照增量分为几组， 然后对分组内的数据进行排序，逐渐缩小增量直至增量为1。

    /*
    * 希尔排序
    * 空间复杂度O(1)
    * 时间复杂度O(n^1.3-1.5)
    * 不稳定
    */
    public static void shellSort(int[] array){
        int gap = array.length;
        while(gap > 1){       //普遍的增量取数组长度的三分之一加一 || 数组长度的二分之一
            gap = gap/3 + 1;
            for(int i= gap ; i < array.length ; i++){
                int tmp = array[i];
                int j = i - gap;
                for(;j >= 0 ; j = j-gap){
                    if(array[j] > tmp){
                        array[j+gap] = array[j];
                    }else{
                        break;
                    }
                }
                array[j+gap] = tmp;
            }

        }
    }

三.选择排序

将所选数字与之后的每一个数字比较大小，若大于则互换位置，循环结束后所选数字为最小值，之后将所选的数字往后移一位。

   /*
    * 选择排序
    * 空间复杂度O(1)
    * 时间复杂度O(n^2)
    * 不稳定
    */
    public static void selectSort(int[] array){
        for(int i = 0 ; i < array.length ; i++){
            for(int j = i ; j < array.length ; j++){
                if(array [j] < array[i] ){
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
    }

四.冒泡排序

比较相邻的数字，大的不断往后移，循环到最后，最后一位为最大值，循环此过程。

  /*
    * 冒泡排序
    * 空间复杂度O(1)
    * 时间复杂度O(n^2)
    * 稳定
    */
    public static void bubbleSort(int[] array){
        for(int i = 0 ; i < array.length - 1 ; i++){
            for(int j = 0 ; j < array.length - 1 - i ; j++){
                if(array[j+1] < array[j]){
                    int tmp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = tmp;
                }

            }
        }
    }

五.快速排序

寻找一个基准使得左边均比基准小，右边均比基准大。将基准左右侧视为一个新的数组，循环此过程。

  /*
    * 快速排序
    * 空间复杂度O(long2n)
    * 时间复杂度O(nlong2n)
    * 不稳定
    */
    public static int partion(int[] array , int start , int end){             //寻找基准
      int tmp = array[start];

      while(start < end){
          while (start < end && array[end] >= tmp){
              end--;
          }
          if(start >= end ){
              array[start] = tmp;
              break;
          }else{
              array[start] = array[end];
          }
          while(start < end && array[start] <= tmp){
              start++;
          }
          if(start >= end){
              array[start] = tmp;
              break;
          }else{
              array[end] = array[start];
          }
      }
      return start;
    }

    public static  void  quickSort(int[] array){
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int par = partion(array, low , high);

        if(par > low+1){
            stack.push(low);
            stack.push(par-1);
        }
        if(par < high - 1){
            stack.push(par+1);
            stack.push(high);
        }
        while(!stack.empty()) {
            high = stack.pop();
            low = stack.pop();

            par = partion(array, low , high);

            if(par > low+1){
                stack.push(low);
                stack.push(par-1);
            }
            if(par < high - 1){
                stack.push(par+1);
                stack.push(high);
            }
        }

    }

六.堆排序

依据数组建立大根堆（最大值为堆顶元素），将堆顶元素与最后一位元素互换位置，则末尾值为最大，end--，再将堆调整为大根堆循环此过程直到end与堆顶元素重合。

    /*
    * 堆排序
    * 空间复杂度O(1)
    * 时间复杂度O(nlog2n)
    * 不稳定
    */
    public static void adjust(int[] array , int parent , int len){
        int child = parent * 2 + 1;
        while(child < len){
            if(child +1 < len && array[child] < array[child + 1]){
                child++;
            }
            if (array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = parent * 2 + 1;
            }else{
                break;
            }
        }
    }

    public static void  createheap(int[] array){
        for(int p = (array.length - 1 - 1) / 2; p >=0 ; p--){
            adjust(array , p , array.length);
        }
    }
    public static void heapSort(int[] array){
        createheap(array);

        int end = array.length - 1;
        while(end > 0){
            int tmp = array[end];
            array[end] = array[0];
            array[0] = tmp;
            adjust(array , 0 , end);
            end--;
        }

    }

七.归并排序

将每一个数组分为原数组一半的两个新数组，不断地重复该过程使得每一数组只有一个元素，此时，每一数组均为有序，再将相邻的数组进行归并为新的数组，

重复归并直至归并为一个数组。

    /*
    * 归并排序
    * 空间复杂度O(log2n)
    * 时间复杂度O(n)     //创建有新的数组
    * 稳定
    */
    public static void merge(int[] array , int start , int mid , int end){
        int[] tmp = new int[end - start + 1];
        int k = 0;
        int s1 = start;
        int e1 = mid ;
        int s2 = mid + 1;
        int e2= end;
        while(s1 <= e1 && s2 <= e2){
            if(array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            }else{
                tmp[k++] = array[s2++];
            }
        }
        while(s1 <= e1){
            tmp[k++] = array[s1++];
        }
        while (s2 <= e2){
            tmp[k++] = array[s2++];
        }

        for(int i = 0 ;i < tmp.length ; i++){
            array[i + start] = tmp[i];
        }
    }

    public static void mergeSortRec(int[] array , int start , int end ){
        if(start >= end){
            return;
        }
        int mid = (start + end)/2;
        mergeSortRec(array , start , mid);
        mergeSortRec(array , mid+1 , end);
        merge(array , start , mid , end);
    }

    public static void mergeSort(int[] array){
        mergeSortRec(array , 0 , array.length-1);
    }

主函数

   public static void main(String[] args) {
        int[] arr = new int[10000];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000);         // 随机生成范围在0-999的数字
        }
        System.out.println(Arrays.toString(arr));


        long start = System.currentTimeMillis();
        heapSort(arr);                             //放置执行的方法
        long end = System.currentTimeMillis();
        System.out.println(Arrays.toString(arr));
        System.out.println("耗时" + (end - start)); //输出执行所消耗的时间
    }
}