JAVA——时间复杂度和空间复杂度

算法效率

如何衡量一个算法的好坏呢？

我们将算法效率分为时间效率和空间效率，又被称为时间复杂度和空间复杂度。
时间复杂度：衡量一个算法的运行速度
空间复杂度：衡量一个算法所需要的额外空间

大O的渐进表示法

1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

时间复杂度

例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); 
}

程序操作执行了2N+1次，时间复杂度为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); 
}

程序操作执行了M+N次，时间复杂度为O(M+N)

例3：计算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; 
	 }
   } 
 }

程序操作最坏执行了(N*(N-1))/2次，则时间按复杂度为O（N^2）

例4：计算binarySerach的时间复杂度？

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;
 }

N *（1/2^x）=1
N / 2^x = 1
N = 2^x
X = log2N
程序操作最坏执行log2N次

例5： 计算阶乘 递归 factorial的时间复杂度？

long factorial(int N) {
 return N < 2 ? N : factorial(N-1) * N;
}

递归的时间复杂度 = 递归次数 * 每次递归后执行的次数
(N-1) * 1
所以时间复杂度为 O(N)

例6：计算斐波那契递归 的时间复杂度？

int fibonacci(int N) { 
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2); }

!](https://img-blog.csdnimg.cn/6787b7fee5cd428da2aa5577d24a8682.png)


所以时间复杂度为 O（2^N）

空间复杂度

例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：

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;
 }

long[N] 动态开辟了N个空间，空间复杂度为 O(N）

例3：计算阶乘递归Factorial的空间复杂度？

long factorial(int N) { return N < 2 ? N : factorial(N-1)*N; }

递归调用了N次，开辟了N个栈帧，每个栈帧开辟了常数个空间。空间复杂度为O（N）

例4：计算空间复杂度