选择排序，冒泡排序，插入排序与对数器

package day01;

import java.util.Arrays;
/**
 * 姓名：张宇健
 * zyj
 * */
public class Suan01Select {

    public static void SelectSort(int[] arr){
        /*选择排序思路：
        *1.先定最小值min，假设i位最小
        *2.遍历第一遍，遇到比min位小的就将那位（j）赋值给min
        *3.交换min和i所在的数值
        *注意：此方法i不用便利到最后一位，因为就是将最小的全都挪到最前面，剩最后一位那肯定就是最大的了
         */
        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            for(int j = i+1;j<arr.length;j++){
                if(arr[min]>arr[j]){
                    min = j;
                }
            }
            swap(arr,i,min);
        }
    }
    public static void BubbleSort(int[] arr){
        /**
         * 冒泡排序思想：
         * 1.依次比较相邻两位，若从小到大排序，则前一位大的两位交换
         * 2.一次比较后，最大的已经到最后一位，之后比较最后一位之前的，依次类推，所以j<length-1-i
         * 注意：此方法和选择排序类似，将最值移到一边，即将最大的移到最后
         *
         * */
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    swap(arr,j+1,j);
                }
            }
        }
    }
    public static void InsertSort(int[] arr){
        /**
         * 插入排序思想：
         * 1.先将0，0位置排好序
         * 2.再将0，1位置排好序
         * 3.再将0，1，2位置排好序
         * 4，依此类推
         * 可以将它比作打扑克的抓牌，排序次序依你
         * 注意：因为这个不是将最值移位，所以i得便利到最后一位，即i<arr.length
         *
         * */
        for (int i = 0; i < arr.length; i++) {
            for(int j = 0;j<=i;j++){
                if(arr[i]<arr[j]){
                    swap(arr,i,j);
                }
            }
        }
    }
    public static void swap(int[] arr,int one,int two){
        if(one!=two) {
            arr[one] = arr[one] ^ arr[two];
            arr[two] = arr[one] ^ arr[two];
            arr[one] = arr[one] ^ arr[two];
        }
    }
    public static int[] RandomTest(int sizeMax,int valueMax){

        int[] arr = new int[(int)(Math.random()*(sizeMax+1))];
        //sizeMax+1的原因：Math.random()产生的是【0，1）左闭右开的区间范围，所以不加1范围是【0，sizeMax）不包含sizeMax，所以加1
        for(int i = 0;i<arr.length;i++){
            //赋值，+1同理
            arr[i] = (int)(Math.random()*(valueMax+1))-(int)(Math.random()*(valueMax));
            //原先只能为【0，valueMax），相减之后可能正，可能负数，可能为零，为了更随机
        }
        return arr;

    }
    public static boolean isEqual(int[] arr,int[] arr2){
        if(arr.length!=arr2.length){
            return false;
        }
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]!=arr2[i]){
                return  false;
            }
        }
        return true;
    }
    public static void main(String[] args){

        //测试数
        int testCount = 100;
        //长度范围
        int sizeMax = 100;
        //取值范围
        int valueMax = 200;
        for (int i = 0; i < testCount; i++) {
            int[] arr2 = RandomTest(sizeMax,valueMax);
            int[] arr2Copy = (int[])Arrays.copyOf(arr2,arr2.length);
            int[] arr2Copy2 = (int[])Arrays.copyOf(arr2,arr2.length);
            SelectSort(arr2);
            BubbleSort(arr2Copy);
            InsertSort(arr2Copy2);
            if(!isEqual(arr2,arr2Copy)){
                System.out.println("错误");
            }
            if(!isEqual(arr2,arr2Copy2)){
                System.out.println("错误");
            }
        }
        System.out.println("正确");


        int[] arr = RandomTest(sizeMax,valueMax);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
//        SelectSort(arr);
//        BubbleSort(arr);
        InsertSort(arr);
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

标签：arr,min,int,插入排序,排好序,冒泡排序,对数,排序,public
来源： https://blog.csdn.net/m0_57733504/article/details/120710417