【基础知识整理】时间复杂度 & 空间复杂度

原文链接：https://blog.csdn.net/fumeidonga/article/details/131070661

时间复杂度是指执行算法所需时间的增长率，而空间复杂度则是指执行算法所需存储空间的增长率。

一、时间复杂度

通常与输入数据进行比较，时间复杂度不是指具体的时间，而是算法的运算次数，是相对于问题规模的相对量。

举例：

当规模增长10倍时，算法的运行时间也增长了10倍，则该算法的时间复杂度为O(1)。如果规模增长10倍时，算法的运行时间增长了100倍，则该算法的时间复杂度为O(10)。

时间复杂度表示方法 - 大 O 表示法

算法的执行时间与每行代码的执行次数成正比，用 T(n) = O(f(n)) 表示，

T(n) ：算法执行总时间，

f(n) ：每行代码执行总次数

n： 数据的规模

实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势。

所以常量、低阶、系数实际上对这种增长趋势不产生决定性影响，我们在做时间复杂度分析时忽略这些项。

假设我们有一段代码

	public static void main(String[] args) {

		int i = 10;
		for (int j = 0; j < i; j++) {
			System.out.println("j" + j);
		}
	}

　　当运行这段代码时，所有语句的执行都需要花费时间，我们假设每条语句的执行时间一样，我们将代码进行拆解，如下

我们将这些次数加起来，总执行次数就 = 3 * i + 3； 当i 趋向于无穷大时， 我们可以忽略常数、低阶项、及高阶系数，这样总执行次数就 = i
T(i) = O(i)

时间复杂度计算

1. 得出运行时间的函数
2. 对函数进行简化，只保留最高阶项 （忽略常数、低阶项、及高阶系数等）

3. 下面我们分别来举例说明

   常数阶
   时间复杂度为 T(n) = O(1)

   function aFun() {
   console.log("Hello, World!"); // 需要执行 1 次
   return 0; // 需要执行 1 次
   }
   

   　　

   我们看到总共要执行2次，我们来简化一下，用1取代所有的常量，就变成了O(1)
   
   时间复杂度为 T(n) = O(n)

   function bFun(n) {
   for(let i = 0; i < n; i++) { // 需要执行 (n + 1) 次
   console.log("Hello, World!"); // 需要执行 n 次
   }
   return 0; // 需要执行 1 次
   }
   

   　　

   总共需要执行 3n + 2次，简化一下，O(n)
   
   时间复杂度为 T(n) = O(n^2)

   function cal(n) {
   let sum = 0; // 1 次
   let i = 1; // 1 次
   let j = 1; // 1 次
   for (; i <= n; ++i) { // n 次
   j = 1; // n 次
   for (; j <= n; ++j) { // n * n ，也即是 n平方次
   sum = sum + i * j; // n * n ，也即是 n平方次
   }
   }
   }
   

    

   时间复杂度为 T(n) = O(log2n)

   let i=1;
   while (i <= n) {
   i = i * 2;
   }
   

   　　

   代码是从 1 开始，每次循环就乘以 2，当大于 n 时，循环结束。
   其实就是高中学过的等比数列，i 的取值就是一个等比数列。在数学里面是这样子的：
   20 21 22 ... 2k ... 2x = n
   所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了，通过 2x = n 求解 x，
   数学中求解得 x = log2n 。所以上面代码的时间复杂度为 O(log2n)。
   
   

   二、空间复杂度
   空间复杂度全称就是渐进空间复杂度（asymptotic space complexity），表示算法的存储空间与数据规模之间的增长关系

   定义：算法的空间复杂度通过计算算法所需的存储空间实现，是对一个算法在运行过程中临时占用存储空间大小的量度

   算法的空间复杂度的计算公式记作：S(n) = O(f(n))，

   空间复杂度计算

   public static void main(String[] args) {
   
   int i = 10;
   for (int j = 0; j < i; j++) {
   System.out.println("j" + j);
   }
   }
   

    

   随着i的变化，所需开辟的内存空间并不会随着i的变化而变化,因为 这 i、j 用的时相同的空间， i 、j各一个，简化一下就是 O（1）

   n ：问题的规模，

   f(n) ：语句关于 n 所占存储空间的函数。

   function print(n) {
   const newArr = []; // 第 2 行
   newArr.length = n; // 第 3 行
   for (let i = 0; i <n; ++i) {
   newArr[i] = i * i;
   }
   
   for (let j = n-1; j >= 0; --j) {
   console.log(newArr[i]) 当消耗空间和输入参数n保持线性增长
   }
   }
   

   　　

   第 2 行代码中，申请了一个空间存储变量 newArr ，是个空数组。
   第 3 行把 newArr 的长度修改为 n 的长度的数组，每项的值为 undefined ，
   除此之外，剩下的代码都没有占用更多的空间，所以整段代码的空间复杂度就是 O(n)
   
   我们常见的空间复杂度就是 O(1)、O(n)、O(n^2)