复杂度估计

时间复杂度

假设OJ上设定运行时间超过1s便报超时，那么

1s 运行O(n),O(n^2),O(logn)的算法分别可以有多少次？

查看CPU参数（一般PC就是在2~3GHz这样）

• 1GHz（兆赫）= 1000MHz（兆赫）
• 1MHz（兆赫）= 1百万赫兹

 1GHz = 10亿Hz，表示CPU可以一秒脉冲10亿次（有10亿个）

 word cpu 2.90GHz，也就是说晶振每秒发出30亿次脉冲（时钟周期）

实现三个函数，时间复杂度分别是 $O(n)$ , $O(n^2)$, $O(n\log n)$，使用加法运算来测试一下。

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;
using namespace chrono;
// O(n)
void function1(long long n) {
    long long k = 0;
    for (long long i = 0; i < n; i++) {
        k++;
    }
}

// O(n^2)
void function2(long long n) {
    long long k = 0;
    for (long long i = 0; i < n; i++) {
        for (long j = 0; j < n; j++) {
            k++;
        }
    }

}
// O(nlogn)
void function3(long long n) {
    long long k = 0;
    for (long long i = 0; i < n; i++) {
        for (long long j = 1; j < n; j = j * 2) { // 注意这里j=1
            k++;
        }
    }
}
int main() {
    long long n; // 数据规模
    while (1) {
        cout << "输入n：";
        cin >> n;
        milliseconds start_time = duration_cast<milliseconds>(
            system_clock::now().time_since_epoch()
            );
        //function1(n);//600000000
        //function2(n);//30000
        function3(n);//30000000
        milliseconds end_time = duration_cast<milliseconds>(
            system_clock::now().time_since_epoch()
            );
        cout << "耗时:" << milliseconds(end_time).count() - milliseconds(start_time).count()
            << " ms" << endl;
    }
}

测试后，在我的机器上1s中能运行复杂度分别为O(n),O(n^2),O(logn)的算法次数大概：

O(n) ：600000000

O(n^2) ：30000

O(logn) ：30000000

递归算法的时间复杂度

递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归中的操作次数。

用求x^n来说明什么是O(logn)的复杂度的算法，和O(n)复杂度算法的区别。

求x^n

直接一个for循环

int function1(int x, int n) {
    int result = 1;  // 注意 任何数的0次方等于1
    for (int i = 0; i < n; i++) {
        result = result * x;
    }
    return result;
}

时间复杂度：O(n)

怎么才O(n)？隔壁老王都会写O(logn)了

提示：使用递归降低复杂度

反手就是一个递归

int function2(int x, int n) {
    if (n == 0) {
        return 1; // return 1 同样是因为0次方是等于1的
    }
    return function2(x, n - 1) * x;
}

背公式：递归的次数 * 每次递归中的操作次数； n * 1 = n

时间复杂度：O(n)

怎么才O(n)？隔壁老王都会写O(logn)了，能不能给点力？

改一改递归

int function3(int x, int n) {
    if (n == 0) {
        return 1;
    }
    if (n % 2 == 1) {
        return function3(x, n / 2) * function3(x, n / 2)*x;
    }
    return function3(x, n / 2) * function3(x, n / 2);
}

背公式：递归的次数 * 每次递归中的操作次数；

算法看成是一颗满二叉树，每个节点算一次 乘法操作，有多少个节点？$2^m+2^{m-1}+\ldots+2^0$ = 2^{m+1} - 1 , m = \log_{2}{n} - 1$ m为递归深度

时间复杂度：O(2^(log_2^n ) ) = O(n)

怎么才O(n)？隔壁老王O(logn)都写了好几个了，你行不行？

上面的算法，显然有重复计算，function3(x, n / 2) * function3(x, n / 2) ，* 两边就做了一样的事情。

---

 

递归有时候的时间复杂度可以很烂甚至是指数复杂度算法

比如说下面这个求斐波那契的算法，老王反手就丢出一个递归

int fibonacci(int i) {
       if(i <= 0) return 0;
       if(i == 1) return 1;
       return fibonacci(i-1) + fibonacci(i-2);
}

小张：哇大佬会递归，好厉害！

Carl：笑死，这都$O(2^n)$算法了，n一大，凉凉！

小张一脸懵逼~：这怎么会是$O(2^n)$算法，你说说，是的话我吃掉

背公式：递归的次数 * 每次递归的时间复杂度

每次递归都是$O(1)$的操作，那看递归了多少次，将i为5作为输入的递归过程 抽象成一颗递归树，如图：

 

 一棵深度为n的二叉树最多可以有 2^n - 1 个节点。所以算法的时间复杂度为$O(2^n)$

这种求斐波那契数的算法看似简洁，其实时间复杂度非常高，一般不推荐这样来实现斐波那契。

主要是两次递归有大量重复计算，导致时间复杂度指数上升

return fibonacci(i-1) + fibonacci(i-2);

 

 老王：我只是试试你而已，我当然会O(n)算法

int fibonacci(int first, int second, int n) {
    if (n <= 0) {
        return 0;
    }
    if (n < 3) {
        return 1;
    }
    else if (n == 3) {
        return first + second;
    }
    else {
        return fibonacci(second, first + second, n - 1);
    }
}

这里相当于用first和second来记录当前相加的两个数值，此时就不用两次递归了。

因为每次递归的时候n减1，即只是递归了n次，所以时间复杂度是 $O(n)$。

同理递归的深度依然是n，每次递归所需的空间也是常数，所以空间复杂度依然是$O(n)$。

---

 

 

$O(\log n)$，行！

int function4(int x, int n) {
    if (n == 0) {
        return 1;
    }
    int t = function4(x, n / 2);// 这里相对于function3，是把这个递归操作抽取出来
    if (n % 2 == 1) {
        return t * t * x;
    }
    return t * t;
}

依然还是看递归了多少次，可以看到这里仅仅有一个递归调用，且每次都是n/2 ，所以这里我们一共调用了 $\log_{2}{n}$ 次function4。

每次递归了做都是一次乘法操作，这也是一个常数项的操作，那么这个递归算法的时间复杂度才是真正的$O(\log n)$。

空间复杂度

主要目的，还是对程序要使用多大内存有个估计，不至于 out of memory ...

栗子

空间复杂度是$O(1)$

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

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

空间复杂度是$O(n)$

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

delete a;

可以看出消耗空间和输入参数n保持线性增长，n多大就开辟多大的空间。

$O(n^2)$， $O(n^3)$， $O(2^n)$如是，最好不要是指数算法。

递归算法空间复杂度

在递归的时候，可能会出现空间复杂度为logn的情况。

那么递归算法的空间复杂度怎么估计呢？

公式：递归算法的空间复杂度 = 每次递归的空间复杂度 * 递归深度

为什么要求递归的深度呢？

因为每次递归所需的空间都被压到调用栈里（这是内存管理里面的数据结构，和算法里的栈原理是一样的），一次递归结束，这个栈就是就是把本次递归的数据弹出去。所以这个栈最大的长度就是递归的深度。

每次递归的空间复杂度，即每次递归需要的栈空间

还是用老王写的斐波那契来说明

非递归dp版本，时间复杂度$O(n)$空间复杂度$O(1)$

int fib(int n) {
    //https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof
    //计算Fibonacci的第n项值  如果初始结果大于1e9+7 即1000000007要取模
    //题解  可以用递归  但是有大量重复运算   
    /*
    //递归  当n太大时，超出时间限制
     if(n <= 1 || n > 100){
        return n;
    }
    return (fib(n-1) + fib(n-2))%1000000007;
    */

    //动态规划 O（N）  O(1)
    if (n <= 1 || n > 100) {
        return n;
    }
    int leftleft = 0;
    int left = 1;
    int num = 0;
    for (int i = 0; i < n - 1; i++) {
        num = (left + leftleft) % 1000000007;
        leftleft = left;
        left = num;
    }
    return num;

}

递归算法，时间复杂度$O(2^n)$空间复杂度$O(n)$

int fibonacci(int i) {
       if(i <= 0) return 0;
       if(i == 1) return 1;
       return fibonacci(i-1) + fibonacci(i-2);
}

优化递归算法时间复杂度$O(n)$空间复杂度$O(n)$

int fibonacci(int first, int second, int n) {
    if (n <= 0) {
        return 0;
    }
    if (n < 3) {
        return 1;
    }
    else if (n == 3) {
        return first + second;
    }
    else {
        return fibonacci(second, first + second, n - 1);
    }
}

求斐波那契数的时候，使用递归算法并不一定是在性能上是最优的，但递归确实简化的代码层面的复杂度。

二分查找递归算法

二分查找的递归实现

int binary_search( int arr[], int l, int r, int x) {
    if (r >= l) {
        int mid = l + (r - l) / 2;
        if (arr[mid] == x)
            return mid;
        if (arr[mid] > x)
            return binary_search(arr, l, mid - 1, x);
        return binary_search(arr, mid + 1, r, x);
    }
    return -1;
}

时间复杂度$O(\log n)$, 空间复杂度$O(\log n)$

二分查找的时间复杂度是$O(\log n)$，那么递归二分查找的空间复杂度是多少呢？

背公式：每次递归的空间复杂度 * 递归深度

每次递归的空间复杂度 ：C++中传入arr是一个地址并不是拷贝，所以每次递归的空间复杂度是常数即：$O(1)$

递归深度：二分查找的递归深度是logn

总的空间复杂度为$O(\logn)$

注意，比如说用python时，转入的参数是整个拷贝，那么再用上面的二分查找空间复杂度就是$O(n\logn)$了。

但是呢，算法的空间复杂度不一定是整个程序跑起来的实际内存消耗，只能说可以用来粗略地估计。

代码的内存消耗

请看Carl哥的讲代码的内存消耗：代码随想录 (programmercarl.com)

为什么要内存对齐？

CPU读取内存不是一次读取单个字节，而是一块一块的来读取内存，块的大小可以是2，4，8，16个字节，具体取多少个字节取决于硬件。

就像GPU中，提高GPU的运行速度的策略之一就是合并对全局内存的访问。

GPU中，读取全局内存时，是一块一块读取的，尽管只希望读取一个地址的元素。如果线程读取或者写入连续的全局内存位置，GPU的效率是最高的，这就叫做 coalesced 合并，是好的。有时候读取的不是连续的一块内存，可能有间隔，那就叫做 strided 跨步，不是很好的。更糟糕的是，如果随机从一个位置读取，那么就需要非常多次内存操作，这就导致 GPU 性能差。

 

有同学会问了，那这样岂不是会消耗内存资源，当然会，但是我们更希望的是速度速度！天下武功，为快不破🐱‍💻