排序（插入排序、希尔排序、选择排序、冒泡排序、快速排序）

import java.util.Arrays;
//时间复杂度O（n^2）对于直接插入排序，数组越有序，越快
//空间复杂度O（1）
//稳定排序
public class TestSort {
    public static void insertSort(int[] array){
        for(int i=1;i<array.length;i++){
            int tmp=array[i];
            int j=i-1;
            for(;j>=0;j--){

                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else{
                    //array[j+1]=tmp;
                    break;
                }
            }
            //j回退到了小于0的地方
            array[j+1]=tmp;
        }

    }
    //希尔排序分组
    public static void shell(int[] array,int gap){
        for(int i=gap;i<array.length;i++){
            int tmp = array[i];
            int j=i-gap;
            for(;j>=0;j-=gap){
                if(array[j]>tmp){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }


    //希尔排序
    public static void shellSort(int[] array){
        int gap=array.length;
        while(gap>1){
            shell(array,gap);
            gap/=2;
        }
        shell(array,1);
    }


    //交换
    public static void swap(int[] array,int i,int j){
        int tmp =array[i];
        array[i]=array[j];
        array[j]=tmp;
    }

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


    //冒泡排序
    public static void bubbleSort(int[] array){
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    swap(array,j+1,j);
                }
            }
        }
    }
    //快速排序
    //时间复杂度：O（N*logn）
    //最坏：数据有序或逆序O（N^2）
    public static void quickSort(int[] array){
        quick(array,0,array.length-1);
    }
    public static void quick(int[] array,int left,int right){
        if(left>=right){
            return;
        }
        int pivot = partition(array,left,right);
        quick(array,left,pivot-1);
        quick(array,pivot+1,right);
    }
    
    public static int partition(int[] array,int start,int end){
        int tmp=array[start];
        while(start<end){
            while(start<end&&array[end]>tmp){
                end--;
            }
            //end下标遇到了小于tmp的值
            array[start]=array[end];
            while(start<end&&array[start]<=tmp){
                start++;
            }
            //start遇到了大于tmp的值
            array[end]=array[start];
        }
        array[end]=tmp;
        return end;
    }