1.算法笔记——认识复杂度和简单排序算法

1.选择排序(时间复杂度O(N*N), 额外空间复杂度O(1))
 代码：
 public static void selectSort(int[] arr) {
   if (arr == null || arr.length < 2) {
     return;
   }
   for (int i = 0; i < arr.length - 1; i++) {
     int minIndex = i;
     for (int j = i + 1; j < arr.length; j++) {
       minIndex = arr[j] < arr[minIndex] ? j : minIndex;
     }
     swap(arr, i, minIndex);
   }
 }
 
 private static void swap(int[] arr, int i, int j) {
   int tmp = arr[i];
   arr[i] = arr[j];
   arr[j] = tmp;
 }
 
 
 
2.冒泡排序(时间复杂度O(N*N), 额外空间复杂度O(1))
 代码：
 public static void bubbleSort(int[] arr) {
   if (arr == null || arr.length < 2) {
     return;
   }
   for (int e = arr.length - 1; e > 0; e--) {
     for (int i = 0; i < e; i++) {
       if (arr[i] > arr[i + 1]) {
         swap(arr, i, i + 1);
       }
     } 
   }
 }
 
 
 
 知识：^(亦或运算)相当于无进位相加；
       获得一个数最右侧的1：eor & (~eor + 1)
 
 3.面试题：
 1)已知一种数出现了奇数次，其他数出现了偶数次，求这个数；
 2)已知两种数出现了奇数次，其他数出现了偶数次，求这两个数；
 要求：时间复杂度O(N), 额外空间复杂度O(1)
 代码：
 1)
 public static int findOne(int[] arr) {
   int eor = 0;
   for (int cur : arr) {
     eor ^= cur;
   }
   return eor;
 }
 
 2)
 public static void findTwo(int[] arr) {
   int eor = 0;
   for (int i = 0; i < arr.length; i++) {
     eor ^= arr[i];
   }
   // eor = a ^ b;
   // eor != 0;
   // eor必有一个位置上是1
   int onlyOne = 0;
   for (int cur : arr) {
     if ((cur & rightOne) == 0) {
       onlyOne ^= cur;
     }
   }
   System.out.println(onlyOne + " " + (eor ^ onlyOne));
 }
 
 
 
 4.插入排序(时间复杂度O(N*N), 额外空间复杂度O(1))
  代码：
  public static void insertSort(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    for (int i = 1; i < arr.length; i++) {
      for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
        swap(arr, j, j + 1);
      }
    }
  }
  
  

5.二分法(不一定有序才能二分)
 1)查找某个数存不存在(有序)
 2)查找大于等于某个数最左边的位置(有序)
 3)arr中，无序，相邻数一定不相等，求任意一个局部最小（eg: 4 2 3  中的2）
 
 代码：
 1)
 public static boolean exist(int[] arr, int num) {
   if (arr == null || arr.length == 0) {
     return false;
   }
   int L = 0;
   int R = arr.length - 1;
   int mid = 0;
   while (L < R) {
     mid = L + ((R - L) >> 1);
     if (arr[mid] == num) {
       return true;
     } else if (arr[mid] > num) {
       R = mid - 1;
     } else {
       L = mid + 1;
     }
   }
   return arr[L] == num;
 }
 
 2)
 public static int findLeft(int[] arr, int num) {
   int L = 0;
   int R = arr.length - 1;
   int index = -1;
   int mid = 0;
   while (L < R) {
     mid = L + ((R - L) >> 1);
     if (arr[mid] >= num) {
       index = mid;
       R = mid - 1;
     } else {
       L = mid + 1;
     }
   }
   return index;
 }
 
 3)
 public static int getLessIndex(int[] arr) {
   if (arr == null || arr.length == 0) {
     return -1;
   }
   if (arr.length == 1 || arr[0] < arr[1]) {
     return 0; 
   }
   if (arr[arr.length - 1] < arr[arr.length - 2]) {
     return arr.length - 1;
   }
   int L = 1;
   int R = arr.length - 2;
   int mid = 0;
   while (L < R) {
     mid = L + ((R - L) >> 1);
     if (arr[mid] > arr[mid - 1]) {
       R = mid - 1;
     } else if (arr[mid] > arr[mid + 1]) {
       L = mid + 1;
     } else {
       return mid;
     }
   }
   return L;
 }
 
 
 
 6.对数器
  //产生随机数组
  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[] arr = new int[(int)(Math.random() * (maxSize + 1))];    //长度随机
    for (int i = 0; i < arr.length; i++) {
      arr[i] = (int)(Math.random() * (maxValue + 1)) - (int)(Math.random() * maxValue);
    }
    return arr;
  }
  
  eg:
  public static void main(String[] args) {
    int testTime = 500000;
    int maxSize = 100;
    int maxValue = 100;
    boolean succeed = true;
    for (int i = 0; i < testTime; i++) {
      int[] arr1 = generateRandomArray(maxSize, maxValue);
      int[] arr2 = copyArray(arr1); //复制数组
      insertionSort(arr1); //写出的方法
      comparator(arr2); //已确认过的能给出正确答案的方法
      if(!isEqual(arr1, arr2)) { //判断两个方法的结果是否相同
        succeed = false;
        break;
      }
    } 
    System.out.println(succeed ? "NICE" : "BAD");
  }