import java.util.Random;

public class Sort {

    private void swap(int[] arr,int i,int j){
        int temp=0;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    /**
     * 列印陣列
     * */
    public void print(int[] arr){
        for(int a: arr){
            System.out.print(a+" "
 
);
        }
    }
    /**
     * 氣泡排序
     * */
    public void maopaoSort(int[] arr, int n){

        for(int i=1;i<n;i++){
            for(int j=0;j<n-i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        print(arr);
    }
    /**
     * 插入排序
     * */
 

    public void insertSort(int[] arr,int n){
        //方案一
        /*for(int i=1;i<n;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    swap(arr, j, j-1);
                }
            }
        }*/
        //方案二
        for(int i=1;i<n;i++){
            int
 
 t=arr[i];
            int j;
            for(j=i-1;j>=0&&arr[j]>t;j--){
                arr[j+1]=arr[j];
            }
            arr[j+1]=t;
        }
        print(arr);
    }
    /**
     * 選擇排序
     * */
    public void selectSort(int[] arr,int n){

        for(int i=0;i<n-1;i++){
            int min=i;
            for(int j=i+1;j<n;j++){
                if(arr[min]>arr[j]){
                    min=j;
                }
            }
            if(min!=i){
                swap(arr,min,i);
            }
        }
        print(arr);
    }

    /**
     * 歸併排序
     * */
    public void mergeSort(int[] arr,int n){
        mergeSort1(arr,0,n-1);
        print(arr);
    }

    private void mergeSort1(int[] arr, int l, int r) {
        if(l>=r){
            return;
        }
        int mid=(l+r)/2;
        mergeSort1(arr,l,mid);
        mergeSort1(arr,mid+1,r);
        merge(arr,l,mid,r);
    }

    private void merge(int[] arr, int l, int mid, int r) {
        int[] temp=new int[r-l+1];

        for(int i=l;i<=r;i++){
            temp[i-l]=arr[i];
        }
        int left=0;
        int right=mid-l+1;
        int m=mid-l;
        for(int i=l;i<=r;i++){
            if(left>m){
                arr[i]=temp[right++];
                continue;
            }
            if(right>temp.length-1){
                arr[i]=temp[left++];
                continue;
            }
            if(temp[left]<temp[right]){
                arr[i]=temp[left++];
            }else{
                arr[i]=temp[right++];
            }

        }

    }

    public void quickSort(int[]arr,int l,int r){
        if(l>=r){
            return;
        }
        //int pivot=partition(arr,l,r); //方案一
        int pivot=partition2way(arr,l,r); //方案二
        quickSort(arr, l,pivot-1);
        quickSort(arr, pivot+1, r);
    }
    /** 方案一
     * 如果重複的太多，會使時間複雜度退化到O（n^2)
     * */
    private int partition(int[] arr, int l, int r) {
        int index=l;
        int pivot=arr[l];
        for(int i=l+1;i<=r;i++){
            if(pivot>arr[i]){
                index++;
                swap(arr,index,i);
            }
        }
        swap(arr,l,index);
        return index;
    }


    private int partition2way(int[] arr,int l,int r){
        int pivot=arr[l];
        int i=l+1;
        int j=r;

        while(true){

            while(i<=r && arr[i]<pivot){
                i++;
            }
            while(j>l && arr[j]>pivot){
                j--;
            }
            if(i>j){
                break;
            }
            swap(arr,i,j);
            i++;
            j--;
        }
        swap(arr,l,j);
        return j;
    }
    /**
     * 三路排序進行優化  <pivot   =pivot   >pivot
     * */
    private void quickSort3way(int[] arr,int l,int r){

        if(l>=r){
            return;
        }
        int pivot=arr[l];
        int i=l;
        int j=r+1;
        int e=l+1;

        while(e<r+1){
            while(e<=r && pivot>arr[e]){
                swap(arr,e,i+1);
                e++;
                i++;
            }
            while(e<=r && pivot==arr[e]){
                e++;
            }
            while(j>l+1 && pivot<arr[j-1]){
                j--;
            }
            if(e==j){
                break;
            }
            swap(arr,e,j-1);
        }
        swap(arr,l,i--);

        quickSort3way(arr,l,i);
        quickSort3way(arr,j,r);
    }

    public static void main(String[] args) {
        Random random=new Random();

        int[] arr=new int[100];

        for(int i=0;i<100;i++){
            arr[i]=random.nextInt(200);
        }

        Sort sort=new Sort();
        /*sort.quickSort(arrr, 0, arrr.length-1);*/
        //sort.quickSort3way(arr, 0, arr.length-1);

        sort.print(arr);
    }
}