冒泡、选择、插入排序

public class Code01_SimpleSort {

    //交换
    public static void swap(int[] arr,int i ,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 选择排序
     * 1.从 下标 0~n-1 中找出最小的放在下标为0的位置，
     * 2.从下标为 1~n-1 中找出找出最小的放在下标为1的位置，
     * 3.从下标为 2~n-1 中找出找出最小的放在下标为2的位置，
     * 从下标i~n-1 中找 最小的放在下标为i的位置,
     * ·····依此类推，直到n-1位置
     * @param arr
     */
    public static void selectSort(int[] arr){
        //边界条件
        if(arr == null || arr.length<2){
            return;
        }
        int N = arr.length;
        for(int i = 0; i<N ;i++){
            int minValueIndex = i; //初始假设i是最小值下标
            for (int j = i+1; j < N; j++) {
                minValueIndex = arr[j]<arr[minValueIndex] ? j : minValueIndex; //找出 从下标i~n-1 中找 最小值的下标
            }
            swap(arr,i,minValueIndex);//交换i位置和最小值位置的值，把最小值放在i位置
        }
    }

    /**
     * 冒泡排序
     * 1.下标0~n-1范围内：下标0~1之间谁大谁往后，1~2之间谁大谁往后，2~3之间谁大谁往后，3~4之间谁大谁往后，·····N-1~N之间谁大谁往后，一轮下来就把最大的值放在最后的位置 N了，
     * 2.下标0~n-2范围内：下标0~1之间谁大谁往后，1~2之间谁大谁往后，2~3之间谁大谁往后，3~4之间谁大谁往后，·····N-3~N-2之间谁大谁往后，一轮下来就把第二大的值放在倒数第二的位置N-1了，
     * 下标0~end范围内：下标end-1~end之间谁大谁往后,·····end-1~end之间谁大谁往后，
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        if(arr == null || arr.length<2){
            return;
        }
        int N = arr.length;
        for (int end = N-1; end >=0 ; end--) {
            for(int second =1; second<=end; second++){
                if(arr[second]<arr[second-1]){
                    swap(arr,second ,second-1);
                }
            }
        }
    }

    /**
     * 插入排序
     * 就像斗地主时，手里已经有一手牌已经排好序了，这时新拿到一张牌，这张牌从右往左看应该插在哪
     * 1.实现0~1 范围上有序
     * 2.实现0~2 范围上有序,
     * ····
     * 实现0~n-1 范围上有序,
     * 新来的数 与 左边已经排好序的数组从右到左比较，如果左边有数，并且左边的数比它大，则交换，新数左移，一直到左边的数不比新数大
     *
     * @param arr
     */
    public static void insertSort(int[] arr){
        if(arr == null || arr.length<2){
            return;
        }
        int N = arr.length;
        for (int end = 1; end < N; end++) {
            //新来的数 与 左边已经排好序的数组从右到左比较，如果左边有数，并且左边的数比它大，则交换，新数左移，一直到左边的数不比新数大
            //pre：新数的前一个位置,新数在end 位置，pre 在end-1位置
            for(int pre = end -1 ; pre >=0 && arr[pre] > arr[pre+1]  ;pre--){
                swap(arr,pre ,pre+1);
            }
        }
    }



    //打印数组
    public static void printArray(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 = {1,7,3,5,9,7,3,8,4,6};
        printArray(arr);
        insertSort(arr);
        printArray(arr);*/

        //对数器
        int maxLen = 10;
        int maxValue = 1000;
        int textTimes = 1000;
        for (int i = 0; i < textTimes; i++) {
            int[] arr1 = lenRandomValueRandom(maxLen,maxValue);
            int[] temp = copyArray(arr1);
            selectSort(arr1);
            if(!isSorted(arr1)){
                System.out.println("选择排序错了,错误示例如下：");
                for (int j = 0; j < temp.length; j++) {
                    System.out.print(temp[j]+" ");
                }
                System.out.println();
            }

        }
    }

    //返回一个长度和大小都随机的数组 arr,arr长度[0，maxLen-1],arr中的每个值[0,maxValue-1]
    public static int[] lenRandomValueRandom(int maxLen,int maxValue){
        int len = (int)(Math.random()*maxLen);
        int[] ans = new int[len];
        for (int i = 0; i < len; i++) {
            ans[i] = (int)(Math.random()*maxValue);
        }
        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 = 1; i < arr.length; i++) {
            if(max > arr[i]){
                return false;
            }
            max = Math.max(max,arr[i]);
        }
        return true;
    }
}