排序算法（更新ing...）

public class 插入排序 {
    public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;++i){
            int j;
            int temp=arr[i];
            for(j=0;j<i;++j){
                if(temp<=arr[j]){
                    break;
                }
            }
            for(int k=i;k>j;--k){
                arr[k]=arr[k-1];
            }
            arr[j]=temp;
        }
    }
}

/*
* 希尔排序：又称缩小增量直接插入排序。习惯：以增量d(初始为数组长度的一半)把数组分组，每组进行直接插入排序。
*           然后，d减半，重复排序直到d=1，进行直接插入排序。
* */
public class 希尔排序 {
    public static void shellSort(int[] arr){
        int d=arr.length/2;//增量
        while(d>0){
            doSort(arr,d);
            d/=2;
        }
    }
    static void doSort(int[] arr,int d){
        for(int i=0;i<d;++i){
            insertSort(arr,i,d);
        }
    }
    //直接插入排序
    static void insertSort(int[] arr,int start,int d){
        for(int i=start+d;i<arr.length;i+=d){
            int temp=arr[i];
            int j;
            for(j=start;j<i;j+=d){
                if(arr[i]<arr[j]){
                    break;
                }
            }
            for(int k=i;k>j;k-=d){
                arr[k]=arr[k-d];
            }
            arr[j]=temp;
        }
    }
}

public class 快速排序 {
    public static void quickSort(int[] arr,int left,int right) {
        //选第一个数作为基准（取中间的数，取第一个数、中间的数、最后一个数的平均值，等）
        if(left>=right) {
            return;
        }
        int key=arr[left];
        int i=left,j=right;
        while(j>i) {
            //比key小的放前面
            while(j>i&&arr[j]>=key) {
                --j;
            }
            arr[i]=arr[j];
            //比key大的放后面
            while(i<j&&arr[i]<=key) {
                ++i;
            }
            arr[j]=arr[i];
                
        }
        arr[i]=key;
        quickSort(arr,left,i-1);
        quickSort(arr, i+1, right);
    }
}