冒泡，插入，选择排序

    //3.2 加入二分查找的插入排序
        private static void binaryInsertSort(int[] a) {
            //依次把每个元素拿来插入到 之前已经有序的子序列当中
            for(int i=0; i<a.length-1; i++){//趟数:n-1  ---除第1个元素，后面的每个元素都拿来插入一次
                //前面i个数已经排好序，现在是准备插入第i+1个数

                //待插入的数
                int temp = a[i+1];

                //※※利用二分算法查找j ---j的定义同3.1
                int low=0;
                int high=i;
                int mid;
                while(low<=high){
                    //System.out.println(low+","+high);
                    mid =(low+high)/2;
                    if(a[mid]>temp){//左半区(所有右半区的数都会比temp大)
                        high=mid-1;
                    }else{//右半区
                        low = mid+1;
                    }
                }
                int j=high;//出循环后，high的位置即是我们想要找的j

                //把[j,i]部分的元素全部往后移一个位置
                for(int k=i;k>j;k--){
                    a[k+1]=a[k];
                }

                //让temp坐在j+1的位置 
                a[j+1]=temp;
            }

        }

    //3.1直接插入排序 ---原序列越有序排得越快 (逆序排得最慢)
    private static void insertSort(int[] a) {
        //依次把每个元素拿来插入到 之前已经有序的子序列当中
        for(int i=0; i<a.length-1; i++){//趟数:n-1  ---除第1个元素，后面的每个元素都拿来插入一次
            //前面i个数已经排好序，现在是准备插入第i+1个数

            //待插入的数
            int temp = a[i+1];

            //找到j ----temp最终是坐在j+1的位置    j的情况:或者是-1，或者是从后往前找到的第一个没有比temp大的数
            int j=i;//从第i个位置开始从后往前依次边查找边移位置
            while(a[j]>temp){
                a[j+1] = a[j];
                j--;
                if(j<0){
                    break;
                }
            }

            a[j+1]=temp;
            //让temp坐在j+1的位置 
        }

    }

    //2.2 选择排序
    private static void selectSort(int[] a) {
        for(int i=0;i<a.length-1;i++){
            //每一趟把最小的放在最前面(第i位置)
            int k=i; //用k记录当前值最小的元素的位置
            for(int j=i+1;j<a.length;j++){
                if(a[k]>a[j]){//拿第k位置的元素去比
                    k=j;
                }
            }
            //经过前面的循环，得到k位置的元素是最小的，然后把它和第i的位置交换
            swap(a,i,k);
        }
    }

    //2.1排手机---近似选择排序
    private static void selectSort0(int[] a) {
        for(int i=0;i<a.length-1;i++){
            //每一趟把最小的放在最前面(第i位置)
            for(int j=i+1;j<a.length;j++){
                if(a[i]>a[j]){
                    swap(a,i,j);
                }
            }
        }
    }


    //1.2优化的冒泡排序
    private static void bubbleSort2(int a[]){
        for(int i=0;i<a.length-1;i++){//趟数:n-1    ----n为数组长度(元素总数)
            //如果存在一趟，没有出现一次交换，那么说明该序列已经有序，不必要再进行排了
            boolean flag=false;
            for(int j=0;j<a.length-1-i;j++ ){
                if(a[j]>a[j+1]){
                    swap(a,j,j+1);
                    flag=true;
                }
            }
            if(flag==false){
                System.out.println(i);
                break;
            }
        }
    }



    //1.1普通的冒泡排序
    private static void bubbleSort(int a[]){
        for(int i=0;i<a.length-1;i++){//趟数:n-1    ----n为数组长度(元素总数)
            //每趟从第0个元素开始，依次两两相邻的元素进行比较，直接到a[n-1-i]和a[n-i]
            for(int j=0;j<a.length-1-i;j++ ){//每趟能冒一个泡(即是当前子序列值最大的那个元素)--放在最后(第n-i位置)
                if(a[j]>a[j+1]){
                    swap(a,j,j+1);
                }
            }
        }
    }
    //交换a[i]和a[j]
    private static void swap(int[]a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    private static void print( int[] a){
        for(int x:a){
            System.out.print(x+"  ");
        }
        System.out.println();
    }


}