算法复习2 以选择排序为例 增加对数器的使用（126行开始）

public class Sort {
    //选择排序
    public  static  void selectSort(int[] arr){
        //1.先想边界条件
        if (arr==null||arr.length<2){
            return;
        }
        int N= arr.length;
        //0~n-1 选一个最小的
        //1~n-1 选一个最小的
        //2~n-1 选一个最小的
        for (int i=0;i<N;i++){
            //设置最小位置的数是i
            int minValueIndex=i;
            //将i之后的数都遍历一边
            for (int j=i+1;j<N;j++){
                //如果arr[j]<arr[minValueIndex]则minValueIndex就等于j
                //否则minValueIndex不变
                minValueIndex=arr[j]<arr[minValueIndex]?j:minValueIndex;
                //自定义一个swap方法
            }
            //i位置的数和minValueIndex位置的数进行交换
            swap(arr,i,minValueIndex);
        }
    }

    //冒泡排序
    public static void bubbleSort(int[] arr){
        if (arr==null||arr.length<2){
            return;
        }
        //0~n-1
        //0~n-2
        //0~n-3
        //0~end
        int N=arr.length;
        for (int end=N-1;end>=0;end--){
            //需要在0~end之间做一些事情
            //01 12 23 34。。。。。。end-1 end
            //01之间1就是second 12之间2就是second
            //将一连串数字拆分成两个一对
            for (int second=1;second<=end;second++){
            //如果second=1号的数字大于second号的数字
            //那就将这两个位置上的数字交换
                   if (arr[second-1]>arr[second]){
                       swap(arr,second-1,second);
                   }
            }
        }
    }

    //插入排序1
    public static void insertSort(int[] arr){
        if (arr==null||arr.length<2){
            return;
        }
        //0~0 完成
        //0~1 需要让它有序
        //0~2 需要让它有序
        //0~3 需要让它有序
        //0~4 需要让它有序
        //0~n-1
        int N= arr.length;
        //因为0的位置已经不需要排序，所以end从1开始
        for (int end=1;end<N;end++){
            int newNumIndex=end;
            //在一个小的分段上 比如0~1上
            //如果newNumIndex-1此时是1，1的左边大于0并且arr[newNumIndex-1]这个
            //位置上的数大于arr[newNumIndex]这个位置上的数
            //则将newNumIndex-1与newNumIndex位置上的元素互换
            //最后newNumIndex的下标-1 -->newNumIndex--;
            while (newNumIndex-1>=0&&arr[newNumIndex-1]>arr[newNumIndex]){
                swap(arr,newNumIndex-1,newNumIndex);
                newNumIndex--;
            }
        }

    }
    //插入排序2 (较1方法更好理解)
    public static void insertSort2(int[] arr){
        if (arr==null||arr.length<2){
            return;
        }
        //0~0 完成
        //0~1 需要让它有序
        //0~2 需要让它有序
        //0~3 需要让它有序
        //0~4 需要让它有序
        //0~n-1
        int N= arr.length;
        //因为0的位置已经不需要排序，所以end从1开始
        for (int end=1;end<N;end++){
            //先定义一个pre前面的数，前提是这个下标必须>=0
            //并且pre下标的元素大于它后面+1的 pre还需要递减 以确保能遍历到0~pre的元素
            for (int pre=end-1;pre>=0&&arr[pre]>arr[pre+1];pre--){
                swap(arr,pre,pre+1);
            }
        }
    }


    public static  void  swap(int arr[],int i,int j){
        //借助中间变量
        int tmp=arr[j];
        arr[j]=arr[i];
        arr[i]=tmp;
    }


    public static void pringArray(int[] arr){
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"");
        }
        System.out.println();
    }
//     public static void main(String[] args) {
//        int[] arr={7,1,3,5,8,6,9,2,0,4};
//        pringArray(arr);
//       // selectSort(arr);
//        //bubbleSort(arr);
//        insertSort2(arr);
//        pringArray(arr);
//
//    }
     //新加对数器的使用
    //返回一个arr，arr长度【0-maxlen-1】 arr中的每个值【0，maxvalue-1】
    public static int[] lenRandomValueRandom(int maxlen,int maxValu){
        int len=(int) (Math.random()*maxlen);
        int[] ans=new int[len];
        for (int i=0;i<len;i++){
            ans[i]=(int) (Math.random()*maxValu);
        }
        return ans;
    }
    //拷贝一个数组
    public static int[] copyArray(int[] arr) {
        int[] ans = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ans[i] = arr[i];
        }
        return ans;
    }

     //检验是否排序成功
    public static boolean isSorted(int[] arr){
        //防止越界
        if (arr.length<2){
            return true;
        }
        int max=arr[0];
        for (int i=0;i<arr.length;i++){
            //如果遍历到的值大于之后的数据 则返回false
            if (max>arr[i]){
                return false;
            }//否则继续排序
            max=Math.max(max,arr[i]);
        }
        return true;
    }

    //测试
    public static void main(String[] args) {
         int maxlen=5;
         int maxValu=1000;
         //测试测试
         int testTime=10000;
         for (int i=0;i<testTime;i++){
             int[] arr1=lenRandomValueRandom(maxlen,maxValu);
             int[] tmp=copyArray(arr1);
             selectSort(arr1);
             //如果选择排序有问题 打印出错误排序
             if (!isSorted(arr1)){
                 for (int j=0;j<tmp.length;j++){
                     System.out.print(tmp[j]+" ");
                 }
                 System.out.println();
                 System.out.println("选择排序错了");
                 break;
             }
             System.out.println("选择排序正确");
             break;
         }

    }
}