认识时间复杂度
- 常数时间的操作：一个操作如果和数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。
- 时间复杂度为一个算法流程中，常数操作数量的指标。常用O（读作big O）来表示。具体来说，在常数操作数量的表达式中，只要高阶项，不要低阶项，也不要高阶项的系数，剩下的部分如果记为f(N)，那么时间复杂度为O(f(N))。
- 评价一个算法流程的好坏，先看时间复杂度的指标，然后再分析不同数据样本下的实际运行时间，也就是常数项时间。
例子一
- 一个简单的理解时间复杂度的例子
- 一个有序数组A，另一个无序数组B，请打印B中的所有不在A中的数，A数组长度为N，B数组长度为M。
- 算法流程1：对于数组B中的每一个数，都在A中通过遍历的方式找一下；
- 算法流程2：对于数组B中的每一个数，都在A中通过二分的方式找一下；
- 算法流程3：先把数组B排序，然后用类似外排的方式打印所有在A中出现的数；
- 三个流程，三种时间复杂度的表达...
- 如何分析好坏？
例子二
对数器的概念和使用
0，有一个你想要测的方法a，
1，实现一个绝对正确但是复杂度不好的方法b，
2，实现一个随机样本产生器
3，实现比对的方法
4，把方法a和方法b比对很多次来验证方法a是否正确。
5，如果有一个样本使得比对出错，打印样本分析是哪个方法出错
6，当样本数量很多时比对测试依然正确，可以确定方法a已经正确。
1 public static void bubbleSort(int[] arr){ 2 //要测试的算法 3 if (arr == null || arr.length < 2){ 4 return; 5 } 6 for (int i=0; i<arr.length-1; i++){ 7 for (int j=0; j<arr.length-1-i; j++){ 8 if (arr[j] > arr[j+1]){ 9 swap(arr, j, j+1); 10 } 11 } 12 } 13 } 14 15 public static void swap(int[] arr, int i, int j){ 16 //交换方法 17 int temp; 18 temp = arr[i]; 19 arr[i] = arr[j]; 20 arr[j] = temp; 21 } 22 23 public static void rightMathod(int[] arr){ 24 //系统提供的排序方法 25 Arrays.sort(arr); 26 } 27 28 public static int[] generateRanddomArray(int size, int value){ 29 //Math.random() -> double[0,1); 左闭右开 30 //(int)((size+1) * Math.random()) -> [0, size]; 左闭右闭整数 31 //size为数组长度 32 33 //生成长度随机的数组 34 int[] arr = new int[(int)((size+1) * Math.random())]; 35 for (int i = 0; i < arr.length; i++){ 36 arr[i] = (int)((value + 1) * Math.random() - (int)(value * Math.random())); 37 } 38 return arr; 39 } 40 41 public static int[] copyArray(int[] arr){ 42 //复制数组的值 43 if (arr == null){ 44 return null; 45 } 46 int[] res = new int[arr.length]; 47 for (int i = 0; i < arr.length; i++){ 48 res[i] = arr[i]; 49 } 50 return res; 51 } 52 53 public static boolean isEqual(int[] arr1, int[] arr2){ 54 //比较两个数组的值是否一样 55 if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)){ 56 return false; 57 } 58 if (arr1 == null && arr2 == null){ 59 return true; 60 } 61 if (arr1.length != arr2.length){ 62 return false; 63 } 64 for (int i = 0; i < arr1.length; i++){ 65 if (arr1[i] != arr2[i]){ 66 return false; 67 } 68 } 69 return true; 70 } 71 72 public static void printArray(int[] arr){ 73 //输出数组 74 if (arr == null){ 75 return; 76 } 77 for (int i = 0; i < arr.length; i++){ 78 System.out.print(arr[i]+" "); 79 } 80 System.out.println(); 81 } 82 83 public static void main(String[] args) { 84 int testTime = 500000; 85 int size = 10; 86 int value = 100; 87 boolean succeed = true; 88 for (int i = 0; i < testTime; i++){ 89 int[] arr1 = generateRanddomArray(size, value); 90 int[] arr2 = copyArray(arr1); 91 int[] arr3 = copyArray(arr1); 92 bubbleSort(arr1); 93 rightMathod(arr2); 94 if (!isEqual(arr1, arr2)){ 95 succeed = false; 96 printArray(arr3); 97 break; 98 } 99 } 100 System.out.println(succeed ? "Nice!" : "Fucking fucked!"); 101 102 int[] arr = generateRanddomArray(size, value); 103 printArray(arr); 104 System.out.println("数组长度为："+arr.length); 105 }
例子三
冒泡排序细节的讲解与复杂度分析
时间复杂度O(N^2)，额外空间复杂度O(1)
1 public static void bubbleSort(int[] arr){ 2 if (arr == null || arr.length < 2){ 3 return; 4 } 5 for (int i=0; i<arr.length-1; i++){ 6 for (int j=0; j<arr.length-1-i; j++){ 7 if (arr[j] > arr[j+1]){ 8 swap(arr, j, j+1); 9 } 10 } 11 } 12 } 13 14 public static void swap(int[] arr, int i, int j){ 15 int temp; 16 temp = arr[i]; 17 arr[i] = arr[j]; 18 arr[j] = temp; 19 } 20 21 public static void show(int[] arr){ 22 for (int i=0; i<arr.length; i++){ 23 System.out.print(arr[i]+" "); 24 } 25 } 26 27 public static void main(String[] args) { 28 int arr[] = {6,4,2,5,8,9}; 29 bubbleSort(arr); 30 show(arr); 31 }
例子四
选择排序的细节讲解与复杂度分析
时间复杂度O(N^2)，额外空间复杂度O(1)
1 public static void selectionSort(int[] arr){ 2 if (arr == null || arr.length < 2){ 3 return; 4 } 5 for (int i = 0; i < arr.length-1; i++){ 6 int minIndex = i; 7 for (int j = i+1; j < arr.length; j++){ 8 minIndex = arr[j] < arr[minIndex] ? j : minIndex; 9 } 10 swap(arr, i, minIndex); 11 } 12 } 13 14 public static void swap(int[] arr, int i, int j){ 15 int temp = 0; 16 temp = arr[i]; 17 arr[i] = arr[j]; 18 arr[j] = temp; 19 } 20 21 public static void show(int[] arr){ 22 for (int i = 0; i < arr.length; i++){ 23 System.out.print(arr[i]+" "); 24 } 25 } 26 27 public static void main(String[] args) { 28 int arr[] = {6,4,1,2,9,3}; 29 selectionSort(arr); 30 show(arr); 31 }
例子五
插入排序的细节讲解与复杂度分析
时间复杂度O(N^2)，额外空间复杂度O(1)
1 public static void insertionSort(int[] arr){ 2 if (arr == null || arr.length < 2){ 3 return; 4 } 5 for (int i = 1; i < arr.length; i++){ 6 for (int j = i-1; j >= 0 && arr[j] > arr[j+1]; j--){ 7 swap(arr, j, j+1); 8 } 9 } 10 } 11 12 public static void swap(int[] arr, int i, int j){ 13 int temp = 0; 14 temp = arr[i]; 15 arr[i] = arr[j]; 16 arr[j] = temp; 17 } 18 19 public static void show(int[] arr){ 20 for (int i = 0; i < arr.length; i++){ 21 System.out.print(arr[i]+" "); 22 } 23 } 24 25 public static void main(String[] args) { 26 int arr[] = {7,3,4,1,9,2,5}; 27 insertionSort(arr); 28 show(arr); 29 }
例子六
刨析递归行为和递归行为时间复杂度的估算
master公式的使用
T(N) = a*T(N/b) + O(N^d)
分析：
T(N)：样本量为 N 的情况下，时间复杂度
N：父问题的样本量
a：子问题发生的次数（父问题被拆分成了几个子问题，不需要考虑递归调用，只考虑单层的父子关系）
b：被拆成子问题，子问题的样本量（子问题所需要处理的样本量），比如 N 被拆分成两半，所以子问题样本量为 N/2
O(N^d)：剩余操作的时间复杂度，除去调用子过程之外，剩下问题所需要的代价（常规操作则为 O(1)）
1) log(b, a) > d -> 复杂度为O(N^log(b, a))
2) log(b, a) = d -> 复杂度为O(N^d * logN)
3) log(b, a) < d -> 复杂度为O(N^d)
例子七
归并排序的细节讲解与复杂度分析
时间复杂度O(N*logN)，额外空间复杂度O(N)
1 public static void mergeSort(int[] arr){ 2 if (arr == null || arr.length < 2){ 3 return; 4 } 5 sortProcess(arr, 0, arr.length-1); 6 } 7 8 public static void sortProcess(int[] arr, int L, int R){ 9 if (L == R){ 10 return; 11 } 12 int mid = (L + R) / 2; //中点下标 13 sortProcess(arr, L, mid); //T(n/2) 14 sortProcess(arr, mid+1, R); //T(N/2) 15 merge(arr, L, mid, R); //O(N) 16 //T(N) = 2 T(N/2) + O(N) 17 } 18 19 public static void merge(int[] arr, int L, int mid, int R){ 20 int[] help = new int[R - L + 1]; 21 int i = 0; 22 int p1 = L; //左侧区域的第一个数 23 int p2 = mid+1; //右侧区域的第一个数 24 while (p1 <= mid && p2 <= R){ 25 help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; 26 } 27 //两个必有且只有一个越界 28 while (p1 <= mid){ 29 help[i++] = arr[p1++]; 30 } 31 while (p2 <= R){ 32 help[i++] = arr[p2++]; 33 } 34 for (i = 0; i < help.length; i++){ 35 arr[L+i] = help[i]; 36 } 37 } 38 39 public static void show(int[] arr){ 40 for (int i=0; i<arr.length; i++){ 41 System.out.print(arr[i]+" "); 42 } 43 } 44 45 public static void main(String[] args) { 46 int[] arr = {5,3,2,6,4,1}; 47 mergeSort(arr); 48 show(arr); 49 }
例子八
小和问题和逆序对问题
小和问题
在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组的小和。
例子：
[1,3,4,2,5]
1左边比1小的数，没有；
3左边比3小的数，1；
4左边比4小的数，1、3；
2左边比2小的数，1；
5左边比5小的数，1、3、4、2；
所以小和为 1+1+3+1+1+3+4+2=16
1 public static int smallSum(int[] arr){ 2 if (arr == null || arr.length < 2){ 3 return 0; 4 } 5 return mergeSort(arr, 0, arr.length-1); 6 } 7 8 public static int mergeSort(int[] arr, int l, int r){ 9 if (l == r){ 10 return 0; 11 } 12 int mid = l + ((r - l) >> 1); 13 return mergeSort(arr, l, mid) + mergeSort(arr, mid+1, r) + merge(arr, l, mid, r); 14 } 15 16 public static int merge(int[] arr, int l, int m, int r){ 17 int[] help = new int[r - l + 1]; 18 int i = 0; 19 int p1 = l; 20 int p2 = m+1; 21 int res = 0; 22 while (p1 <= m && p2 <= r){ 23 res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0; 24 help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; 25 } 26 while (p1 <= m){ 27 help[i++] = arr[p1++]; 28 } 29 while (p2 <= r){ 30 help[i++] = arr[p2++]; 31 } 32 for (i = 0; i < help.length; i++){ 33 arr[l + i] = help[i]; 34 } 35 return res; 36 } 37 38 public static void main(String[] args) { 39 int[] arr = {1,3,4,2,5}; 40 System.out.println(smallSum(arr)); 41 }
逆序对问题
在一个数组中，左边的如果比右边的数打，则折两个数构成一个逆序对，请打印所有逆序对。