时间复杂度计算方法

在学习数据结构阶段，认识的第一个概念应该就是时间复杂度了。时间复杂度是一个数学上的一个函数式，该函数式计算的基本执行次数，就是时间复杂度。通俗的说，时间复杂度就是衡量这个算法的运行时间长短，效率高低的一个手段，它是通过粗略的计算算法的执行次数来衡量的。那时间复杂度该怎么计算呢？

一、计算算法的时间复杂度：

下面先看这段代码：

//判断算法的时间复杂度
#include<stdio.h>

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--)
    {
        ++count;
    }
    printf("%d\n", count);
}

int main()
{
    int N = 0;
    scanf("%d", &N);
    Func1(N);
    return 0;
}

上面的代码中，Func1函数效率的高低，就能衡量这个函数的好坏。观察出该函数有四个循环，前两个循环是嵌套的形式，每个循环的循环次数是N次，所以一共是N×N次。第三个循环的循环次数是2×N次，第四个循环的循环次数是10次，所以该函数一共执行了N×N+2×N+10次，写成数学表达式就是Func1(N) = N² + 2×N + 10。

带入具体值是：

N值	准确值（Func1(N) = N² + 2 × N + 10）	估算值（Func1(N) = N²）
N = 1	Func1(N) = 13	Func1(N) = 1
N = 10	Func1(N) = 130	Func1(N) = 100
N = 100	Func1(N) = 10210	Func1(N) = 10000
N = 1000	Func1(N) = 1002010	Func1(N) = 1000000
N = 10000	Func1(N) = 100020010	Func1(N) = 100000000
N = 100000	Func1(N) = 10000200010	Func1(N) = 10000000000

N值越大，估算值与准确值之间相差的就越少，也就是说估算值就越接近准确值，那么就可以用估算值代替准确值，得到的执行次数就是算法Func1的大致执行次数。

实际上这样做有些过于细节了，时间复杂度求的是一个算法的大致运行次数，所以并不是精确到到底是多少次，那么时间复杂度就会存在着等级，比如O(1)、O(N)、O(2×N)、O(N²)、O(log₂N)、O(N!)、O(Nlog₂N)等，N就代表该算法大致执行了多少次，1代表该算法执行的是常数次，也就是确定的次数，这种表示的方法是大O渐进表示法。

上面的Func1函数的时间复杂度是O(N²)，也就是大致执行了N²次，比如当N = 10时，Func1(N) = 100，这显然是一个大致的数字，之所以舍弃后面的次数，是因为当N无限大时，能决定具体的执行次数的是N²，不是2×N+10，所以会舍弃后面的执行次数，这点在当N无限大时就很明显。

如果算法执行次数是确定的呢，那时间复杂度又是多少？其实，不管这个确定的执行次数有多大，时间复杂度都是O(1)，“1”也代表常数次，比如下面的代码：

//判断算法的时间复杂度
#include<stdio.h>

void Func3(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++k)
    {
        ++count;
    }
    printf("%d\n", count);
}

int main()
{
    int N = 0;
    scanf("%d", &N);
    Func3(N);
    return 0;
}

代码就是循环100次，所以时间复杂度是O(1)。

只要是O(1)就说明该算法执行次数是常数次，不管确定的常数值多大或多小都是O(1)。这是因为CPU的处理速度已经非常快了，所以即使几十亿次的执行，也不过是几秒钟而已，当然如果一个O(1)的算法需要执行几百万亿甚至几千万亿次，这也需要很长时间的，即使这种算法的时间复杂度是O(1)，实际上也是不太可能存在的。

时间复杂度大小关系为：O(log₂N) < O(N) < O(Nlog₂N) < O(N²) < O(2^N) < O(N!)。

二、时间复杂度的量级：

从上面的分析就可以看出，时间复杂度是分等级的，最快的也是最优的是O(1)、O(log₂N)，其次是O(N)、O(Nlog₂N)，这些时间复杂度都是比较不错的。然后是O(N²)，这种时间复杂度的算法效率就很低了，在实际生活中一般是不用的，最后是O(N!)，这种时间复杂度的算法也就是看看而已，很少很少存在，因为它的效率实在是太低了。

只是这么说可能不太直观的感受，下面使用具体数值举例，时间复杂度每个量级之间的差距：

O(log₂N)	O(N)	O(Nlog₂N)	O(N²)	O(2^N)	O(N!)
1	1	1	1	1	1
7	100	700	10,000	2^100	100!
14	10,000	140,000	100,000,000	没有计算必要了	没有计算必要了
17	100,000	1,700,000	10,000,000,000	没有计算必要了	没有计算必要了
20	1,000,000	20,000,000	没有计算必要了	没有计算必要了	没有计算必要了
24	10,000,000	240,000,000	没有计算必要了	没有计算必要了	没有计算必要了
27	100,000,000	2,700,000,000	没有计算必要了	没有计算必要了	没有计算必要了
30	1,000,000,000	30,000,000,000	没有计算必要了	没有计算必要了	没有计算必要了

这下就可以看出效率了，时间复杂度为O(N)的算法还算可以，之后的算法就比较拉胯了，到了O(N²)的算法基本没人使用了。

三、求时间复杂度时的预期管理：

有如下程序：

//判断算法的时间复杂度
#include<stdio.h>

const char* strchr(const char* str, int character);

int main() {}

上面的函数没有具体的实现，也就不知道是执行常数次还是N次，也就是说，最好的情况是执行1次（常数次），最坏的情况是执行N次，平均的情况（最常见的情况）是执行次数在区间[2,N-1]之之间，那就不知道这个算法到底执行多少次，这时可以采用预期管理，按照最坏的情况考虑。

遇到不确定的执行次数时，均按照最坏情况考虑。

所以上面算法的时间复杂度是O(N)。

四、求算法的时间复杂度的方法：

1、最简单的情况，直接数循环次数即可，根据循环次数判断是在哪个量级。

2、大部分的算法都需要特殊考虑，到底执行次数是在哪个量级，比如下面的代码：

//判断算法的时间复杂度
#include<stdio.h>

long long Fib(size_t N)
{
    if (N < 3)
        return 1;
    return Fib(N - 1) + Fib(N - 2);
}

int main()
{
    size_t N = 0;
    scanf("%d", &N);
    Fib(N);
    return 0;
}

这个算法看起来很简单，功能是求第N个斐波那契数，但是想要计算出时间复杂度还是比较复杂的。首先算法中含有函数递归，每一次函数递归都会开辟一个函数栈帧，这也算执行了一次，那问题就转换成这个算法到底递归了多少次即可。

函数递归过程如下：

Fib(N)函数递归过程：
                                                             Fib(N)                                                                  2º
                            Fib(N-1)                                              Fib(N-2)                                     2¹
           Fib(N-2)                Fib(N-3)                   Fib(N-3)                  Fib(N-4)                     2²
Fib(N-3)  Fib(N-4)    Fib(N-4)  Fib(N-5)    Fib(N-4)  Fib(N-5)    Fib(N-5)  Fib(N-6)            2³
                                                                 ...                                                                      ...
                                                               Fib(5)
                               Fib(4)                                                       Fib(3)
                 Fib(3)                return = 1                     return = 1           return = 1 
return = 1       return = 1

从上面的递归过程发现，前期的调用大概是按照2ⁿ的形式调用的，后面当N<3时，就会返回1。所以如果是按照量级看来，大致计算执行次数应该是2º + 2¹ + 2² + 2³ + ... + 2^(n - 1) = 2ⁿ - 1。所以时间复杂度就是O(2ⁿ)。

错位相减计算法：
S(n) = 2º + 2¹ + 2² + 2³ + ... + 2^(n - 1)
2×S(n) = 2¹ + 2² + 2³ + ... + 2ⁿ
可知S(n) = 2ⁿ - 2º = 2ⁿ - 1。

还有一种求法，就是画出前几个递归图后，就大概判断出执行次数差不多是2ⁿ，少算的那部分根本不用管，这样就推测出时间复杂度是O(2ⁿ)了，这个也是求算法的时间复杂度中比较难的一个了。

以上就是我这次分享的内容啦！写的不好，请多担待！