时间复杂度和空间复杂度

我们所谓的时间复杂度关注的是程序运行的快慢（时间上的效率）
空间复杂度程序指的是程序运行时占用的内存/外存的空间多少。

O(N):中的N表示元素个数，O(N)表示基本操作大概执行了多少次（N次）

N^2 + 2*N + 10
O(N^2)

O渐进表示法，只是关注基本操作执行次数的数量级，不必算的很精确。

public static void Fun(int[] arr){
        //这样的操作，无论数组的元素个数有几个
        //基本操作都是执行固定次数（不一定是1次）
        //就可以记作 O(1)
        System.out.println("hehe");
        System.out.println("hehe");
        System.out.println("hehe");
    }

如果最高阶项带系数的，也不要系数
只关注数量级，只关注大概是多少，而不关注具体的精确的次数。

实例1：

// 计算func2的时间复杂度？
void func2(int N) {
int count = 0;
for (int k = 0; k < 2 * N ; k++) {
   count++; }
int M = 10;
while ((M--) > 0) {
   count++; }
System.out.println(count);
}
//O(N)

实例2：

// 计算func3的时间复杂度？
void func3(int N, int M) {
int count = 0;
for (int k = 0; k < M; k++) {
   count++; }
for (int k = 0; k < N ; k++) {
   count++; }
System.out.println(count);
}
//O(M+N)

实例3

// 计算func4的时间复杂度？
void func4(int N) {
int count = 0;
for (int k = 0; k < 100; k++) {
   count++; }
System.out.println(count);
}
//O(1),常量复杂度，100与N无关

实例4：冒泡排序

// 计算bubbleSort的时间复杂度？
void bubbleSort(int[] array) {
for (int end = array.length; end > 0; end--) {
   boolean sorted = true;
   for (int i = 1; i < end; i++) {
       if (array[i - 1] > array[i]) {
           Swap(array, i - 1, i);
           sorted = false;
       }
   }
   if (sorted == true) {
       break;
   }
}}
//外层循环遍历一次
//里层循环遍历一次
//O(N^2)

实例5：二分查找

// 计算binarySearch的时间复杂度？
int binarySearch(int[] array, int value) {
int begin = 0;
int end = array.length - 1;
while (begin <= end) {
   int mid = begin + ((end-begin) / 2);
   if (array[mid] < value)
       begin = mid + 1;
   else if (array[mid] > value)
       end = mid - 1;
   else
       return mid; }
return -1; 
}
//找规律

实例6：

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1) * N; 
}
//O(N)

实例7：

// 计算斐波那契递归fibonacci的时间复杂度？
int fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}
//O(2^N)

空间复杂度：

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

实例1 ：冒泡排序

// 计算bubbleSort的空间复杂度？
void bubbleSort(int[] array) { 
 for (int end = array.length; end > 0; end--) { 
 boolean sorted = true; 
 for (int i = 1; i < end; i++) { 
 if (array[i - 1] > array[i]) { 
 	Swap(array, i - 1, i); 
	 sorted = false; 
 	} 
 } 
		 if (sorted == true) { 
			 break; 
		 } 
	 } 
}
//O(1)
常量空间复杂度

实例2：

// 计算fibonacci的空间复杂度？
int[] fibonacci(int n) { 
 long[] fibArray = new long[n + 1]; 
 fibArray[0] = 0; 
 fibArray[1] = 1; 
 for (int i = 2; i <= n ; i++) { 
 	fibArray[i] = fibArray[i - 1] + fibArray [i - 2]; 
 } 
 	return fibArray; 
}
// 实例2动态开辟了N个空间，空间复杂度为 O(N)

实例3：递归版本求阶乘

// 计算阶乘递归Factorial的时间复杂度？
long factorial(int N) { 
 return N < 2 ? N : factorial(N-1)*N; 
}

每一层函数调用，都需要一定的空间来存参数