算法学习左神第一节课

左神第一节课，讲解了时间复杂度的概念，简单排序，异或运算，二分查找，对数器

public class SimpleSortingXORBisector {
    /*
      一个操作如果和样本的数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。
      在表达式中，只要高阶项，不要低阶项，也不要高阶项的系数，剩下的部分如果为f(N)，那
      么时间复杂度为O(f(N))。
      评价一个算法流程的好坏，先看时间复杂度的指标，然后再分析不同数据样本下的实际运行
      时间，也就是“常数项时间”。
     */

    /**
     * JDK工具类排序
     * @param arr
     */
    public static void systemSort(int[] arr){
        Arrays.sort(arr);
    }
    /**
     * 选择排序
     * 从下标 i 开始遍历，每次选最小的数与 i 交换
     * 从 0 遍历到 n-1
     * @param arr
     */
    public static void selectionSort(int[] arr){
        int n=arr.length;
        if (n<2){
            return;
        }
        int minIndex;
        for (int i = 0; i <n; i++) {
            minIndex=i;
            // 找到最小元素的数组下标
            for (int j = i+1; j < n; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr,i,minIndex);
        }
    }

    /**
     * 冒泡排序
     * 若第 j 位置的元素大于第 j+1 位置的元素，则交换
     * 从 0 遍历到末尾，遍历n-1次
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        int n=arr.length;
        if (n<2){
            return;
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    swap2(arr,j,j+1);
                }
            }
        }
    }

    /**
     * 插入排序,平均时间复杂度比选择排序和冒泡排序小
     * 每次遍历得到从第 0 项到第 i 项有序
     * i从 0 到 n-1
     */
    public static void insertSort(int[] arr){
        int a,b;
        for (int i = 1; i < arr.length; i++) {
            for (int j = i-1; j >=0 && arr[j]>arr[j+1]; j--) {
                swap(arr,j+1,j);
            }
        }
    }

    /**
     * 数组两个索引位置的交换
     * @param arr
     * @param i
     * @param minIndex
     */
    public static void swap(int[] arr, int i, int minIndex){
        int temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
    }

    /**
     * 异或运算（无进位相加）交换
     * 交换律:a ^ b=b ^ a
     * 相同律:a ^ a=0
     * 不变律:a ^ 0=a
     * 交换条件:被交换的两数存储空间不同
     * @param arr
     * @param i
     * @param j
     */
    public static void swap2(int[] arr,int i,int j){
        arr[i]=arr[i] ^ arr[j];
        arr[j]=arr[i] ^ arr[j];
        arr[i]=arr[i] ^ arr[j];
    }

    /**
     * 用异或运算找到数组中唯一出现奇数次的元素
     * @param arr
     */
    public static void findOneOdd(int[] arr){
        int eor=0;
        for (int j : arr) {
            eor ^= j;
        }
        System.out.println(eor);
    }

    /**
     * 用异或运算找到数组中唯二出现奇数次的元素
     * @param arr
     */
    public static void findTwoOdd(int[] arr){
        int eor1=0;
        int eor2=0;
        for (int j:arr) {
            eor1^=j;
        }
        // 提取出最右边的1
        int rightOne=eor1 & (~ eor1+1);
        for (int j:arr) {
            if ((j & rightOne)==0){
                eor2^=j;
            }
        }
        eor1=eor1^eor2;
        System.out.println(eor1+" "+eor2);
    }
    /**
     * 打印数组元素
     * @param arr
     */
    public static void printArr(int[] arr){
        for (int j : arr) {
            System.out.print(j + " ");
        }
        System.out.println();
    }

    /**
     * 随机生成数组元素
     * @param length
     * @return
     */
    public static int[] getArr(int length,int value){
        Random random = new Random();
        length=random.nextInt(length)+1;
        ArrayList<Integer> nums = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            nums.add(random.nextInt(value)+1);
        }
        int[] arr=new int[length];
        for (int i = 0; i < length; i++) {
            arr[i]=nums.get(i);
        }
        return arr;
    }

    /**
     * 二分查找
     * 若数组元素存在，则返回对应下标
     * @param arr
     * @param num
     * @return
     */
    public static int dichotomyFindNum(int[] arr,int num){
        int left=0,right=arr.length-1,mid=0;
        if (arr[left]==num){
            return left;
        }
        if (arr[right]==num){
            return right;
        }
        while (left<right){
            mid=(left+right)/2;
            if (mid==left){
                if (arr[right]==num){
                    return right;
                }else {
                    return -1;
                }
            }
            if (arr[mid]>num){
                right=mid;
            } else if (arr[mid]<num){
                left=mid;
            }else {
                return mid;
            }
        }
        return -1;
    }

    /**
     * 二分查找
     * 找到大于等于num的最左边的数组元素下标
     * @param arr
     * @param num
     * @return
     */
    public static int dichotomyFindGreOrEqLeft(int[] arr,int num){
        int left=0,right=arr.length-1,mid=1;
        if (arr[right]<num){
            return -1;
        }
        if (arr[left]>=num){
            return left;
        }
        while (left<right){
            mid=(left+right)/2;
            if (left==mid){
                return right;
            }
            if (arr[mid]>=num){
                right=mid;
            } else if (arr[mid]<num){
                left=mid;
            }
        }
        return right;
    }

    /**
     * 二分查找
     * 找到一个元素满足局部最小值
     * @param arr
     * @return
     */
    public static int dichotomyFindLocalMinimum(int[] arr){
        int left=0,right=arr.length-1,mid=1;
        if (arr[left]<arr[left+1]){
            return left;
        }
        if (arr[right]<arr[right-1]){
            return right;
        }
        while (left<right){
            mid=(left+right)/2;
            if (arr[mid-1]>arr[mid]&&arr[mid+1]>arr[mid]){
                return mid;
            }
            if (arr[mid]>arr[mid-1]){
                right=mid-1;
            } else if (arr[mid]>arr[mid+1]){
                left=mid+1;
            }
        }
        return left;
    }

    /**
     * 对数器
     * 用来比较两个算法的正确性
     */
    public static void logarithmicDetector(){
        int maxSize=1000;
        int maxValue=100000;
        int maxN=10000;
        for (int i = 0; i < maxN; i++) {
            int[] arr = getArr(maxSize, maxValue);
            int[] arr1 = Arrays.copyOf(arr,arr.length);
            systemSort(arr);
            insertSort(arr1);
            for (int j = 0; j < arr.length; j++) {
                if (arr[j]!=arr1[j]){
                    System.out.println("Error");
                    return;
                }
            }
        }
        System.out.println("Right");
    }

    public static void main(String[] args) {
        logarithmicDetector();
//        int[] aa={1,2,3,4,5};
//        insertSort(aa);
//        int[] a = getArr(10,100);
//        bubbleSort(a);
//        printArr(a);
//        int[] b={1,1,3,3,5,5,7,7,9,9,2};
//        findOneOdd(b);
//        int[] c={1,1,3,3,5,5,7,7,9,9,2,4};
//        findTwoOdd(c);
//        bubbleSort(c);
//        printArr(c);
//        int find = dichotomyFindNum(c, 9);
//        System.out.println(find);
//        int leftIndex = dichotomyFindGreOrEqLeft(c, 3);
//        System.out.println(leftIndex);
//        int[] d={4,3,2,4,3,4,5,7};
//        int i = dichotomyFindLocalMinimum(d);
//        System.out.println(i+"="+d[i]);
    }

}