2020-8-10 谈时间复杂度和空间复杂度

时间复杂度和空间复杂度是用来评价算法效率高低
概念：
    时间复杂度：就是说执行算法需要消耗的时间长短，越快越好。
    空间复杂度：就是说执行当前算法需要消耗的存储空间大小，也是越少越好。
时间复杂度：

1.表示方法：
一般用“大O符号表示法”来表示时间复杂度：T(n) = O(f(n))，n是影响复杂度变化的因子，f(n)是复杂度具体的算法。

1.循环次数最多原则：

当n变得越来越大时，公式中的低阶，常量，系数三部分影响不了其增长趋势，可以直接忽略他们，
只记录一个最大的量级就可以了。计算时间复杂度时，只需关注循环次数最多的那段代码即可。
int sumFunc(int n) {
int sum = 0; //执行1次，忽略不计
for (int i = 0; i < n; i++) {
sum += i; // 循环内执行次数最多，执行次数为n次，因此时间复杂度记为O(n)
}
return sum; //执行1次，忽略不计
}

 2.加法原则:

for (int i = 0; i < n; i++) {
sum += i; //执行n次 O(n)
}
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++) {
sum += i; //执行n*n次 O(n*n)
}
}
上述两断代码的时间复杂度分别为 O(n)和O(n*n)，T(n)=O(n)+O(n*n)，但我们只取最大的量级即O(n*n)
量级最大的那段代码时间复杂度=总的时间复杂度

3.乘法原则

嵌套代码的复杂度等于嵌套内外代码复杂度的乘积
int sum = 0;
for (int i = 0; i < n; i++) 
{            
for (int j = 0; j < n; i++); //执行n次
{
sum += 1; //执行n次
}
}
因此这段代码时间复杂度为O(n) * O(n) = O(n*n) = O(n*n)

2.常见的时间复杂度量级

常数阶O(1)  eg：

int a=1；
int b=2;
int c=3;
各执行一次，时间复杂度为 O(1);
for (int i = 0; i < 100; i++) {
printf("hello"); //执行一百次，也是常量级，记为O(1)
}

大O符号表示法并不是用于来真实代表算法的执行时间的，它是用来表示代码执行时间的增长变化趋势的。
上面的算法并没有随着某个变量的增长而增长，所以无论多长，时间复杂度都为O(1).

线性阶O(n)  eg :

for(int i=0;i {
    
}
上面的循环要执行N次，所以时间复杂度为O(n)。

对数阶O(logN)

int a= 1;
while(a < n) 
{
    a = a * 2;
}
执行x次之后 x=log2(n),把2换成其他数也是一样（换底公式：loga(b)*logc(a)=logc(b)）
所以时间复杂度为O(logN)

线性对数阶O(nlogN)

for(int i=0;i {
while(a {
i=i*2;
}
}
for循环嵌套while循环 即时间复杂度为 O(n)*O(logN)  O(nlogN)

平方阶O(n²)

for (int i = 0; i < n; i++) 
{            
for (int j = 0; j < n; i++); //执行n次
{
}
}

两个for循环嵌套

此时的时间复杂度为O(n*n).

空间复杂度：
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的一个量度，同样反映的是一个趋势，
S(n)= O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。
空间复杂度比较常用的有：O(1)、O(n)

O(1)

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

代码中的 i、j、m 所分配的空间都不随着处理数据量变化，因此它的空间复杂度 S(n) = O(1)

O(n)

int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

这段代码中，第一行new了一个数组出来，这个数据占用的大小为n，
这段代码的2-6行，虽然有循环，但没有再分配新的空间，
因此，这段代码的空间复杂度主要看第一行即可，即 S(n) = O(n)

总结：
对于一个算法来说，空间复杂度和时间复杂度往往是相互影响的。当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，即可能导致占用较多的存储空间；反之，当追求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。
有时我们可以用空间来换取时间以达到目的。