import java.util.Arrays;

public class AllSort {
    public static void main(String[] args){
        int[] arr={2,9,3,6,1,0,1};
        //selectSort(arr);
        //bubbleSort(arr);
        //insertSort(arr);
        //shellSort(arr);
        //shellSort2(arr);
        //mergeSort(arr);
        //quickSort(arr);
        heapSort(arr);
        for(int i:arr){
            System.out.print(i+" ");
        }
    }
    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    
    // 最好的情况：正序，交换0次，比较O(n^2)
    // 最坏的情况：交换n-1次，比较O(n^2) 
    // 平均O(n^2)
    // 不稳定 eg：5 6 5 2 原来相等的数据排序后交换了顺序
    // 空间复杂度O(1)
    public static void selectSort(int[] arr){
        if(arr==null || arr.length ==0){
            return;
        }
        for(int i=0;i<arr.length;i++){
            int minIndex=i;
            for(int j=i;j<arr.length;j++){
                if(arr[j]<arr[minIndex]){
                    minIndex=j;
                }
            }
            swap(arr,i,minIndex);
        }
    }
    
    //最好的情况：正序，比较n-1次，交换0次，复杂度O(n)
    //最坏的情况：逆序，交换O(n^2)，比较O(n^2)
    //平均：O(n^2)
    //稳定的
    //空间O(1)
    public static void bubbleSort(int[] arr){
        if(arr==null || arr.length==0){
            return;
        }
        boolean isSwap=false;
        for(int i=arr.length-1;i>=0;i--){
            isSwap=false;
            for(int j=0;j<i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr, j, j+1);
                    isSwap=true;
                }
            }
            if(!isSwap) return;
        }
    }
    
    //最好的情况：正序，比较n-1次，移动0次，复杂度O(n)
    //最坏的情况：逆序，交换O(n^2)，移动O(n^2)，复杂度O(n^2)
    //平均：O(n^2)
    //稳定的
    //空间O(1)
    public static void insertSort(int[] arr){
        if(arr==null || arr.length ==0){
            return;
        }
        for(int i=1;i<arr.length;i++){
            int key=arr[i];
            int j=i;
            while (--j>=0 && arr[j]>key) {
                arr[j+1]=arr[j];
            }
            arr[j+1]=key;
        }
    }
    
    /*改进的插入排序算法
     *eg：主键最小的元素在最后面，则将它移动到正确位置需要移动n-1次
     *希尔排序是为了改进插入排序，交换不相邻的元素以对数组的局部进行排序，
     *并最终用插入排序将局部有序的数组排序。
     *把记录按下标的一定增量分组，对每一组数据使用插入排序，
     *一个h有序数组则是h个有序子数组组成的，
     *随着增量逐渐减少每组包含的关键词越来越多，
     *当增量减至1时，整个文件恰被分成一组，算法便终止。
    */
    //最好 O(n^s)，最坏O(n^s)，实际复杂度和增量序列有关，
    //s[1,2]之间，取决于增量序列，一般最好O(n^1.3)
    //shell在排好序的情况下比插入排序要差的
    //eg：1234，插入比较3次，shell，d=2，[1,3][2,4]比较2次，
    //然后d=d/2=1[1,2,3,4]比较3次，总共比较5次
    public static void shellSort(int[] arr){
        if(arr==null ||arr.length==0){
            return;
        }
        int N=arr.length;
        int h=1;
        while(h < N/3) h=3*h+1;//1,4,13,40,121,...
        while (h >= 1) {
            //将数组变为h有序
            for (int i = h; i < N; i++) {
                //将a[i]插入到a[i-h],a[i-2*h],a[i-3*h]...通过交换相邻元素法
                for(int j=i;j>=h&&arr[j]<arr[j-h];j-=h){
                    swap(arr, j, j-h);
                }
            }
            h=h/3;
        }
    }
    //移动数组法
    public static void shellSort2(int[] arr){
        if(arr==null ||arr.length==0){
            return;
        }
        int N=arr.length;
        int gap=1;
        while(gap < N/3) gap=3*gap+1;//1,4,13,40,121,...
        while(gap>=1){
            for(int i=gap;i<arr.length;i++){
                int key=arr[i];
                int j=i;
                while(j-gap>=0 && arr[j-gap]>key){
                    arr[j]=arr[j-gap];
                    j-=gap;
                }
                arr[j]=key;
            }
            gap=gap/3;
        }
        
    }
    
    //最好&最坏&平均O(nlogn)，空间O(n)，稳定的
    public static void mergeSort(int[] arr){
        if(arr==null || arr.length==0){
            return;
        }
        mergeSort(arr,0,arr.length-1);
    }
    private static void mergeSort(int[] arr,int lo,int hi){
        if(lo>=hi){
            return;
        }
        int mid=(lo+hi)>>1;
        mergeSort(arr,lo,mid);
        mergeSort(arr,mid+1,hi);
        merge(arr,lo,mid,hi);
    }
    private static void merge(int[] arr,int lo,int mid,int hi){
        int[] left=Arrays.copyOfRange(arr, lo, mid+1);
        int[] right=Arrays.copyOfRange(arr, mid+1, hi+1);
        int i=0,j=0,k=lo;
        while (i<left.length && j<right.length) {
            if(left[i]<right[j]){
                arr[k++]=left[i++];
            }
            else{
                arr[k++]=right[j++];
            }
        }
        while(i<left.length){
            arr[k++]=left[i++];
        }
        while(j<right.length){
            arr[k++]=right[j++];
        }
    }
    
    
    //正序和逆序的情况都是最差的，每次迭代只减少一个元素O(n^2)
    //最好的情况，每次切分的元素正确位置都于序列的中间，O(nlogn)
    //平均O(nlogn)，为了避免最坏的情况可以进行shuffle
    //空间O(1)
    //不稳定
    public static void quickSort(int[] arr){
        if(arr==null || arr.length==0){
            return ;
        }
        quickSort(arr,0,arr.length-1);
    }
    private static void quickSort(int[] arr,int lo,int hi){
        if(lo>=hi){
            return;
        }
        int j=partition(arr,lo,hi);
        quickSort(arr, lo, j-1);
        quickSort(arr, j+1, hi);
    }
    private static int partition(int [] arr,int lo,int hi){
        int i=lo;
        int key=arr[lo];
        int j=hi+1;
        while (true) {
            while (arr[++i]<key) {
                if(i==hi) break;
            }
            while (arr[--j]>key) {
                if(j==lo) break;
            }
            if(i>=j) break;
            swap(arr, i, j);
        }
        swap(arr, lo, j);
        return j;
    }
    
    
    //建堆O(n)，最好，最坏，平均nlogn，空间O(1)
    public static void heapSort(int[] arr){
        if(arr==null||arr.length==0){
            return;
        }
        for(int i=(arr.length-1)/2;i>=0;i--){
            adjustMaxHeap(arr,i,arr.length);
        }
        for (int i = arr.length-1; i >= 0; i--) {
            swap(arr, i, 0);
            adjustMaxHeap(arr, 0, i);
        }
    }
    private static void adjustMaxHeap(int[] arr,int i,int lastIndex){
        int left=2*i+1;
        int right=2*i+2;
        int maxIndex=i;
        if(left <lastIndex &&arr[left] >arr[maxIndex]){
            maxIndex=left;
        }
        if(right<lastIndex && arr[right] >arr[maxIndex]){
            maxIndex=right;
        }
        if(i != maxIndex){
            swap(arr, maxIndex, i);
            adjustMaxHeap(arr, maxIndex, lastIndex);
        }
    }
}