算法基础杂项

目录

1算法最优解

 2.时间复杂度排序

3.对数器 

---

1算法最优解

1.首先，保证时间复杂度最低

2.其次，保证空间复杂度最低

3.常数项低不低，一般没人管

 2.时间复杂度排序

 

3.对数器 

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        Boolean isSuccess = true;
        // 执行次数
        int testTimes = 500000;
        // 定义随机数组的长度 0~100
        int maxSize = 100;
        // 定义随机数组中元素的范围 -100 ~ 100
        int maxValue = 100;
        //step 1 生成随机数组
        int[] array = generateRandomArray(maxSize, maxValue);
        //step 2 拷贝出一份，共三份
        int[] copyArray1 = copyArray(array);
        int[] copyArray2 = copyArray(array);
        //step3  两份copy的数组分别用不同的算法执行，执行的结果进行比较，每次执行的每个位置的元素都能对的上，返回 success，否则，返回 failed，并打印出保存的数组
        for (int i = 0; i < testTimes; i++) {
            //    算法1
            insertionSort(copyArray1);
            //    算法2
            comparator(copyArray2);
            boolean isTrue = isSortResultEqual(copyArray1, copyArray2);
            if (!isTrue) {
                for (int j = 0; j < array.length; j++) {
                    System.out.print(array[j] + " ");
                }
                isSuccess = false;
                break;
            }
        }
        System.out.println(isSuccess ? "success!" : "Fucking fucked!");
    }

    private static boolean isSortResultEqual(int[] copyArray1, int[] copyArray2) {
        if ((copyArray1 == null && copyArray2 != null) || (copyArray1 != null && copyArray2 == null)) {
            return false;
        }
        if (copyArray1 == null && copyArray2 == null) {
            return true;
        }
        if (copyArray1.length != copyArray2.length) {
            return false;
        }
        for (int i = 0; i < copyArray1.length; i++) {
            if (copyArray1[i] != copyArray2[i]) {
                return false;
            }
        }
        return true;

    }

    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    public static int[] generateRandomArray(int maxSize, int maxValue) {
        // Math.random() -> [0,1) 所有的小数，等概率返回一个
        // Math.random() * N -> [0,N) 所有小数，等概率返回一个
        // (int)(Math.random() * N) -> [0,N-1] 所有的整数，等概率返回一个

        int[] array = new int[(int) ((maxSize + 1) * Math.random())]; // 长度随机
        for (int i = 0; i < array.length; i++) {
            //两个随机数相减，可能得到随机正，负，零
            array[i] = (int) (Math.random() * (maxValue + 1)) - (int) (Math.random() * (maxValue + 1));

        }
        return array;
    }

    public static int[] copyArray(int[] array) {
        if (array == null || array.length == 0) {
            return null;
        }
        int[] array2 = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            array2[i] = array[i];
        }
        return array2;
    }

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 不只1个数
        for (int i = 1; i < arr.length; i++) { // 0 ~ i 做到有序
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    // i和j是一个位置的话，会出错
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}