时间复杂度

1. 时间复杂度为一个算法流程中， 常数操作数量的指标。 常用O（读作big O） 来表示。 具体来说， 在常数操作数量的表达式中，
   只要高阶项， 不要低阶项， 也不要高阶项的系数， 剩下的部分如果记为f(N)， 那么时间复杂度为O(f(N))。

   ---

   
   
2. （例一）一个简单的理解时间复杂度的例子一个有序数组A， 另一个无序数组B， 请打印B中的所有不在A中的数， A数组长度为N， B数组长度为M。
   算法流程1： 对于数组B中的每一个数， 都在A中通过遍历的方式找一下；
   算法流程2： 对于数组B中的每一个数， 都在A中通过二分的方式找一下；
   算法流程3： 先把数组B排序， 然后用类似外排的方式打印所有在A中出现的数；
   三个流程， 三种时间复杂度的表达...
   算法流程1所需要的时间复杂度为O(M*N)        算法流程2  二分的方式：首先将数组遍历，然后取中间数跟要取的数比较，依次进行。需要的次数为 log₂N。时间复杂度为O( log₂N)，总共时间复杂度为O(M*log₂N)。   算法流程3  外排 将两个有序数组依次比较，谁小动哪个数组，直到两数组相等打印。排序时间复杂度为O(N*log₂N)，第二步比较时间复杂度O(N+M),总的时间复杂度为：O(N*log₂N)+O(N+M) 根据样本量来化简。
   比较：算法流程1直接排除，算法流程2和算法流程3确定N、M数据量来比较。

   ---

3. 冒泡排序：从第一个数，相邻两个数比较大小，若前一个数比后一个数大就交换，依次进行，排到最后，最大的数在最右端。继续从一个开始，排到N-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);
   				}
   			}
   		}
   

   　　时间复杂度为O(N²)

4. 选择排序：从数组中选择最小的数放在第一位置，然后在剩下的数中选择最小得数放在第二位置，以此类推。

      public static void selectionSort(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);
           }

   时间复杂度为O(N²)

5. 插入排序：0位置数确定，1位置与0位置上数比较，如果小就交换，2位置上数与1位置上数比较，若小就交换，然后在与0位置上的数比较大小，以此类推。类似抓扑克牌。

       public static void insertionSort(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);
               }
           }

   与数据状况有关系，若排好序时间复杂度为O(N),若是逆序则时间复杂度为O(N²)。

6. 对数器的概念和使用
   0） 有一个你想要测的方法a
   1）实现一个绝对正确但是复杂度不好的方法b
   2）实现一个随机样本产生器
   3）实现比对的方法
   4）把方法a和方法b比对很多次来验证方法a是否正确
   5）如果有一个样本使得比对出错， 打印样本分析是哪个方法出错 
   6）当样本数量很多时比对测试依然正确， 可以确定方法a已经正确 
   

   // for test 随机数发生器
       public static int[] generateRandomArray(int maxSize, int maxValue) {
           int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
           for (int i = 0; i < arr.length; i++) {
               arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random()); //产生正负值
           }
           return arr;
       }
               //Math.random() ->double [0,1)
               //(int)((size + 1)*Math.random()) ->[0,size]

   
   
7. 完整代码

   package basic_class_01;
   
   import java.util.Arrays;
   
   public class Code_01_InsertionSort {
   
       public static void insertionSort(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);
               }
           }
       }
   
       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];
       }
   
       // for test
       public static void comparator(int[] arr) {
           Arrays.sort(arr);
       }
   
       // for test
       public static int[] generateRandomArray(int maxSize, int maxValue) {
           int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
           for (int i = 0; i < arr.length; i++) {
               arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
           }
           return arr;
       }
   
       // for test
       public static int[] copyArray(int[] arr) {
           if (arr == null) {
               return null;
           }
           int[] res = new int[arr.length];
           for (int i = 0; i < arr.length; i++) {
               res[i] = arr[i];
           }
           return res;
       }
   
       // for test
       public static boolean isEqual(int[] arr1, int[] arr2) {
           if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
               return false;
           }
           if (arr1 == null && arr2 == null) {
               return true;
           }
           if (arr1.length != arr2.length) {
               return false;
           }
           for (int i = 0; i < arr1.length; i++) {
               if (arr1[i] != arr2[i]) {
                   return false;
               }
           }
           return true;
       }
   
       // for test
       public static void printArray(int[] arr) {
           if (arr == null) {
               return;
           }
           for (int i = 0; i < arr.length; i++) {
               System.out.print(arr[i] + " ");
           }
           System.out.println();
       }
   
       // for test
       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!" : "Fucking fucked!");
   
           int[] arr = generateRandomArray(maxSize, maxValue);
           printArray(arr);
           insertionSort(arr);
           printArray(arr);
       }
   
   }