1.4 算法和算法分析（时间复杂度和空间复杂度）

目录

1.4 💎算法效率分析

1. 时间复杂度

（1）定义：

（2）计算

2. 空间复杂度

（1）定义

（2）计算

---

1.4 💎算法效率分析

1. 时间复杂度

（1）定义：

一个算法中的语句执行次数称为语句频度或时间频度，记为T(n)，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f (n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

📢      n↑，时间复杂度↑，算法执行效率↓

（2）计算

• 我们知道常数项对函数的增长速度影响并不大，所以当 T(n) = c，c 为一个常数的时候，我们说这个算法的时间复杂度为 O(1)；如果 T(n) 不等于一个常数项时，直接将常数项省略。
• 我们知道高次项对于函数的增长速度的影响是最大的。n^3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的。 同时因为要求的精度不高，所以我们直接忽略低此项。
• 因为函数的阶数对函数的增长速度的影响是最显著的，所以我们忽略与最高阶相乘的常数。

假设计算机运行一行基础代码需要执行一次运算，那么下边这个方法需要执行 2 次运算

int aFunc(void) {
    printf("Hello, World!\n");      // 需要执行 1 次
    return 0;                       // 需要执行 1 次
}

 📢    T(n) = 2，其复杂度为O(1)

在for循环中

int aFunc(int n) {
    for(int i = 0; i<n; i++) {         // 需要执行 (n + 1) 次
        printf("Hello, World!\n");     // 需要执行 n 次
    }
    return 0;                          // 需要执行 1 次
}

计算次数：n+1+n+1=2n+2

📢     T(n) = 2n+2，其复杂度为O(2n)

👀

T(n) = n^3 + n^2 + 29，此时时间复杂度为 O(n^3)。

T(n) = 3n^3，此时时间复杂度为 O(n^3)。

T(n) = n + 29，此时时间复杂度为 O(n)

单个循环体的推导

对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个循环的时间复杂度为 O(n×m)。

void aFunc(int n) {
    for(int i = 0; i < n; i++) {         // 循环次数为 n
        printf("Hello, World!\n");       // 循环体时间复杂度为 O(1)
    }
}

 此时时间复杂度为 O(n × 1)，即 O(n)。

多重循环体的推导

对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c...，则这个循环的时间复杂度为O(n×a×b×c...)。分析的时候应该由里向外分析这些循环。

void aFunc(int n) {
    for(int i = 0; i < n; i++) {            // 循环次数为 n
        for(int j = 0; j < n; j++) {        // 循环次数为 n
            printf("Hello, World!\n");      // 循环体时间复杂度为 O(1)
        }
    }
}

此时时间复杂度为 O(n × n × 1)，即 O(n^2)。

多个时间复杂度的推导

对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。

void aFunc(int n) {
    // 第一部分时间复杂度为 O(n^2)
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            printf("Hello, World!\n");
        }
    }
    // 第二部分时间复杂度为 O(n)
    for(int j = 0; j < n; j++) {
        printf("Hello, World!\n");
    }
}

此时时间复杂度为 max(O(n^2)，O(n))，即 O(n^2)。

条件语句的推导

对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。

void aFunc(int n) {
    if (n >= 0) {
        // 第一条路径时间复杂度为 O(n^2)
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                printf("输入数据大于等于零\n");
            }
        }
    } else {
        // 第二条路径时间复杂度为 O(n)
        for(int j = 0; j < n; j++) {
            printf("输入数据小于零\n");
        }
    }
}

此时时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

🚩   时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。

时间复杂度参考：(2条消息) 十分钟搞定时间复杂度（算法的时间复杂度）_swadian2008的博客-CSDN博客_计算时间复杂度

2. 空间复杂度

（1）定义

         算法整个运行过程中所占用的空间称为空间复杂度，记为S(n) = O(f(n))，n为问题的规模，空间复杂度记作S (n)，S(n)依然使用大O来表示。利用程序的空间复杂度，可以对程序运行中需要多少内存有个预先估计。

（2）计算

        空间复杂度为  O(1)  的eg🍭🍭🍭：

int j = 0;
for (int i = 0; i < n; i++) {
    j++;
}

随着n的变化，所需开辟的内存空间不变，并不会随着n的变化而变化。即此算法空间复杂度为一个常量，所以表示为大O(1)。

        空间复杂度为  O(n)  的eg🍭🍭🍭：

int* a = new int(n);
for (int i = 0; i < n; i++) {
    a[i] = i;
}

定义的数组占用的大小为n，虽然有一个for循环，但没有分配新的空间，所以，这段代码的空间复杂度主要看第一行，随着n的增大，开辟的内存大小呈线性增长，即 O(n)。

空间复杂度是logn的情况有些特殊，在递归的时候，会出现空间复杂度为logn的情况