# 时间复杂度和空间复杂度

# 一、算法效率的度量方法

# 1. 事后统计方法

这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低。

# 2. 事前分析估算方法

在计算机程序编写前，依据统计方法对算法进行估算。

经过总结，我们发现一个高级语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：

1. 算法采用的策略，方案
2. 编译产生的代码质量
3. 问题的输入规模
4. 机器执行指令的速度

# 二、算法时间复杂度

# 1. 算法时间复杂度定义

在进行算法分析时，语句总的执行次数 T(n)是关于问题规模 n 的函数，进而分析 T(n)随 n 的变化情况并确定 T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n)= O(f(n))。它表示随问题规模 n 的增大，算法执行时间的增长率和 f(n)的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中 f(n)是问题规模 n 的某个函数。

用大写 O()来体现算法时间复杂度的记法，我们称之为大 O 记法。

一般情况下，随着输入规模 n 的增大，T(n)增长最慢的算法为最优算法。 显然，由此算法时间复杂度的定义可知，我们的三个求和算法的时间复杂度分别为 O(1)，O(n)，O(n^2)。

# 2.推导大 O 阶方法

如何分析一个算法的时间复杂度呢？即如何推导大 O 阶呢？

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

# ① 常数阶 O(1)

int sum = 0, n = 100;
printf(“I love you.com\n”);
printf(“I love you.com\n”);
printf(“I love you.com\n”);
printf(“I love you.com\n”);
printf(“I love you.com\n”);
printf(“I love you.com\n”);
sum = (1+n)*n/2;

# ② 线性阶 O(n)

一般含有非嵌套循环涉及线性阶，线性阶就是随着问题规模 n 的扩大，对应计算次数呈直线增长。

int i , n = 100, sum = 0;
for( i=0; i < n; i++ )
{
    sum = sum + i;
}

# 平方阶 O(n²)

int i, j, n = 100;
for( i=0; i < n; i++ )
{
    for( j=0; j < n; j++ )
    {
        printf(“I love FishC.com\n”);
    }
}

n 等于 100，也就是说外层循环每执行一次，内层循环就执行 100 次，那总共程序想要从这两个循环出来，需要执行 100*100 次，也就是 n 的平方。所以这段代码的时间复杂度为 O(n^2)。

总结：如果有三个这样的嵌套循环就是 n^3。所以总结得出，循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。

# ④ 对数阶 O(logN)

还是先来看代码：

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

从上面代码可以看到，在 while 循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。我们试着求解一下，假设循环 x 次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，那么 x = log2^n 也就是说当循环 log2^n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(logN)

# 线性对数阶 O(nlogN)

线性对数阶 O(nlogN) 其实非常容易理解，将时间复杂度为 O(logn)的代码循环 N 遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了 O(nlogN)。

就拿上面的代码加一点修改来举例：

for(m=1; m<n; m++) { i = 1; while(i<n) { i = i * 2; } }

对应的线性图：

常用的时间复杂度所耗费的时间从小到大依次是： O(1) < O(logn) < (n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

# 三、最坏情况与平均情况

我们查找一个有 n 个随机数字数组中的某个数字，最好的情况是第一个数字就是，那么算法的时间复杂度为 O(1)，但也有可能这个数字就在最后一个位置，那么时间复杂度为 O(n)。

平均运行时间是期望的运行时间。

最坏运行时间是一种保证。在应用中，这是一种最重要的需求，通常除非特别指定，我们提到的运行时间都是最坏情况的运行时间。

# 四、算法的空间复杂度

我们在写代码时，完全可以用空间来换去时间。

举个例子说，要判断某年是不是闰年，你可能会花一点心思来写一个算法，每给一个年份，就可以通过这个算法计算得到是否闰年的结果。

另外一种方法是，事先建立一个有 2050 个元素的数组，然后把所有的年份按下标的数字对应，如果是闰年，则此数组元素的值是 1，如果不是元素的值则为 0。这样，所谓的判断某一年是否为闰年就变成了查找这个数组某一个元素的值的问题。

第一种方法相比起第二种来说很明显非常节省空间，但每一次查询都需要经过一系列的计算才能知道是否为闰年。第二种方法虽然需要在内存里存储 2050 个元素的数组，但是每次查询只需要一次索引判断即可。

这就是通过一笔空间上的开销来换取计算时间开销的小技巧。到底哪一种方法好？其实还是要看你用在什么地方。

定义：算法的空间复杂度通过计算算法所需的存储空间实现，算法的空间复杂度的计算公式记作：S(n)=O(f(n))，其中，n 为问题的规模，f(n)为语句关于 n 所占存储空间的函数。

通常，我们都是用“时间复杂度”来指运行时间的需求，是用“空间复杂度”指空间需求。

当直接要让我们求“复杂度”时，通常指的是时间复杂度。

显然对时间复杂度的追求更是属于算法的潮流！

# 空间复杂度 O(1)

如果算法执行所需要的临时空间不随着某个变量 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)