JAVA修炼秘籍第六章《鏖战》

往期：
JAVA 修炼秘籍第一章：《痛苦的折磨》
JAVA 修炼秘籍第二章：《逐渐魔化》
JAVA 修炼秘籍第三章：《绝地反击》
JAVA 修炼秘籍第四章：《闭关修炼》
JAVA 修炼秘籍第五章：《卧薪尝胆》

---

---

一、时间复杂度/空间复杂度

评价段代码的好坏抛去简洁健壮可移植性等等，我们想到的就是这个程序快不快呀，想想计算机算一个题就比你用草稿纸算一个题快10秒20秒，你还会花半天心思时间敲代码吗，所以代码的时间复杂度非常重要，空间复杂度相比现在这个时代，没那么特别重要，但是还是有的，不能写个计算器，电脑没内存了对吧。

1.时间复杂度

如何计算时间复杂度？不能跟奥运会似的，拿个秒表计时吧，所以还是要有公式的，在很久以前，我们的前辈，也就是老大牛们，研究了一个公式来计算一个程序的时间复杂度，简单来说就是，算法中的基本操作的执行次数，为算法的时间复杂度。

大O阶表示法（复杂度都有什么等级？）：
O(1)——>O(log n)——>O(n)——>O(n log)——>O(n²)——>O(n³)——>O(2ⁿ)——>O(n!)——>O(nⁿ)
一般从2ⁿ后就很少用到了。

我们知道了等级，那怎么评估一段代码的时间复杂度是在什么等级。
接下来是推到大O阶方法：
1.常用数1取代运行时间中的所有加法常数。
2.在修改后的运行次数函数中，只保留最高阶。
3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数
得到的结果就是大O阶。

第一题：练习一下看看能不能算出来

// 请计算一下func1基本操作执行了多少次？
void func1(int N){
   int count = 0;
   for (int i = 0; i < N ; i++) {
       for (int j = 0; j < N ; j++) {
           count++;
       }
   }
   for (int k = 0; k < 2 * N ; k++) {
       count++;
   }
   int M = 10;
   while ((M--) > 0) {
       count++;
   }
   System.out.println(count);
}

得到公式如上，通过我们刚才所提到的推到大O阶方法进行简化。
答案是：O(n²)。
前面忘说到一点就是，如果这是一个长度为N的数组，那么你要找一个数：
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，我们一般表示一个程序的时间复杂度也都表示的最坏情况。

第二题：

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

答案：F(N)=2*N+10;结果为O(n)。

第三题：

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

答案：F(N)=N+M;结果为O(N+M)。

第四题：

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

答案：F(N)=100;结果为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(n²)。

第六题：

// 计算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; }

答案：O(log n)。

第七题：

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

答案：结果为O(n)。

第八题：

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

答案：O(2ⁿ)。

2.空间复杂度

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

第一题：

// 计算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）

第二题：

// 计算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; }
}

答案为：O(N）

第三题：

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

答案为：O(N）

本章主要讲述时间复杂度与空间复杂度，感谢观赏。再见~