数据结构与算法之时间复杂度和空间复杂度（C语言版）

1. 时间复杂度

1.1 概念

简而言之，算法中的基本操作的执行次数，叫做算法的时间复杂度。也就是说，我这个程序执行了多少次，时间复杂度就是多少。

比如下面这段代码的执行次数：

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);
}

Func1执行的基本操作次数：

F(N) = N^2 + 2*N + 10

在这里两层for循环的次数是N^2，第二个for循环的次数是2*N，while循环的次数是10
所以这个算法中的基本操作次数就是 N^2 + 2*N + 10。

那我们的时间复杂度就是这个吗，其实不是的。实际上我们在计算时间复杂度的时候，我们并不一定要计算精确的执行次数，而只需要大概执行次数。

这又是为什么呢？

当N = 10的时候，F(N) = 130

当 N = 100 的时候，F(N) = 10210

当 N = 1000 的时候，F(N) = 1002010

我们发现当N趋于无穷大的时候，对F(N)影响最大的是N^2，这就跟我们在数学里找极限一样，抓大头，找影响最大的一项，用影响最大的一项来表示我们的时间复杂度

这种表示方法我们称作大O的渐进表示法。

1.2大O的渐进表示法
 

大O符号（Big O notation）：用于描述函数渐进行为的数学符号。
 

基本执行次数用大O阶方法表示的规则：
 

1. 如果执行次数中出现加法常数（无论多大，只要是常数），用1来代替。

2. 如果执行次数是多项式，执行次数只保留最高阶项（最高次项）

3. 如果最高阶项存在且不是1，舍去系数。

4.经过1，2，3操作得到的结果就是大O阶表示。

所以我们上面的F(N) = N^2 + 2*N + 10 用大O阶表示就是 O(N^2)。
 

1.3 最好，平均，最坏情况

有些算法的时间复杂度是存在最好，平均，最坏情况的。

1.最好情况：基本操作次数的最小值

2.平均情况：期望的基本操作次数

3.最坏情况：基本操作次数的最大值

但是在实际中我们都是用最坏情况来表示时间复杂度

1.4 时间复杂度例题

1.4.1 例题1

void Func2(int N)
{
    int count = 0;
    for (int k = 0; k < 2 * N ; ++ k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}

答案：O(N)

基本执行次数是（2 * N + 10），用大O阶表示为O(N)

1.4.2 例题2

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

答案：O(M+N)

基本执行次数是M+N次，由于有两个未知数M和N，所以大O阶表示为O(M+N)

1.4.3 例题3

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

答案：O(1)

基本执行次数是100次，用大O阶表示为O(1)

1.4.4 例题4

void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
        {
            if (a[i-1] > a[i])
            {
                Swap(&a[i-1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
            break;
    }
}

答案：O(N^2)

基本操作次数是(n-1)+(n-2)+(n-3)+....+3+2+1 = ((n + 1) * n) / 2

最好情况就是遍历一次就排序成功，基本操作次数是n-1，大O阶表示是O(N)

最坏情况就是全部遍历完，基本操作次数是((n + 1) * n) / 2，大O阶表示为O(N^2)

时间复杂度一般看最坏情况，为O(N^2)

大O表示为O(N^2)

1.4.5 例题5

int BinarySearch(int* a, int n, int x)
{
    assert(a);
    int begin = 0;
    int end = n-1;
    // [begin, end]：begin和end是左闭右闭区间，因此有=号
    while (begin <= end)
    {
        int mid = begin + ((end-begin)>>1);
        if (a[mid] < x)
            begin = mid+1;
        else if (a[mid] > x)
            end = mid-1;
        else
            return mid;
    }
    return -1;
}

答案：O(log N)

这个算法是二分查找

最好情况是查找一次，为O(1)

最坏情况是begin = end 了，只剩了一个元素，我们可以设循环的次数是x，一次循环我们是砍掉了一半的数组元素，那到最后没有元素了，说明n / 2^x = 1  

所以x = log n(以2为底)。时间复杂度的大O阶表示就是O(logN)。

我们规定以2为底的对数函数写成 log N 

1.4.6 例题6

long long Fac(size_t N)
{
    if(0 == N)
        return 1;

    return Fac(N-1)*N;
}

答案：O(N)

基本操作次数：这个函数一共递归了N次，时间复杂度就是O(N)

1.4.7 例题7

long long Fib(size_t N)
{
    if(N < 3)
        return 1;

    return Fib(N-1) + Fib(N-2);
}

答案：O(2^N)

基本操作次数：这个函数递归了1+2+4+8+... 是一个不完整的等比数列，在N<3之后不会递归，但是不影响整体的趋势，可以忽略不计，这个等比数列的和是2^n - 1

所以大O阶表示为O(2^n)

2.空间复杂度

2.1概念

空间复杂度指的是临时占用存储空间大小的量度，需要注意的是空间复杂度并不是程序占了多少个字节的空间，因为没有什么太大意义，所以空间复杂度指的是新创建的变量个数

空间复杂度计算规则和时间复杂度基本一致，用大O阶渐渐表示法。

注意⚠️⚠️⚠️：

1. 计算空间复杂度时，一般不需要考虑函数的形式参数。空间复杂度主要关注的是算法执行过程中所占用的额外空间，而函数的形式参数在函数调用时会被压入调用栈中，属于函数调用过程中的内存分配，并不计入空间复杂度的计算。

2. 递归算法在每次递归调用时需要维护函数调用栈，而函数调用栈会占用额外的内存空间，所以其空间复杂度为递归所使用的堆栈空间的大小。

2.2 空间复杂度例题

2.2.1 例题1

void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i) 
        {
            if (a[i - 1] > a[i]) 
            {
                Swap(&a[i - 1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
            break;
    }
}

这个冒泡排序临时创建的变量分别是 end ， exchange 和 i  一共三个，是常数个。

所以空间复杂度用大O阶表示为O(1)

2.2.2 例题2

long long* Fibonacci(size_t n)
{
    if(n==0)
        return NULL;

    long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; ++i)
    {
        fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
    }
    return fibArray;
}

这个算法我们直接看新创建的变量是fibArray这个数组，是动态开辟的一个数组，开辟了n+1个空间，还有个i变量，一共是n+2个变量。

用大O阶表示为O(n)

2.2.3 例题3

long long Fac(size_t N)
{
    if(N == 0)
        return 1;

    return Fac(N-1)*N;
}

首先我们要明确的是这是一个函数递归调用

我们函数递归一共要递归N次，共创建新的栈空间N个

所以空间复杂度为O(N)

2.2.4 例题4

long long Fib(size_t N)
{
    if(N < 3)
        return 1;

    return Fib(N-1) + Fib(N-2);
}

此时的空间复杂度是多少呢？ O(2^N)？ 还是O(N)？

我们画图来说明

---

我们来看这个函数的递归调用并不是同时进行的，而是先调用左边的，左边调用完了，最下面Fib（2）往回销毁空间之后才去调用Fib（1），也就是在这个时候才开辟Fib（1）的空间

蓝色箭头代表从Fib（3）到Fib（2）先开辟Fib（2）的栈空间，当调用结束的时候，这段空间就要销毁，于是就有了红色的箭头代表销毁Fib（2）的空间，销毁之后我们才开始调用Fib（1），绿色箭头代表调用Fib（1），此时就要开辟Fib（1）的空间，要知道的是我们刚刚销毁一个栈空间，现在又要开辟一个栈空间，所以空间是被重复利用的，也就是黄色的箭头，Fib（1）的空间跟Fib（2）的空间是同一块空间。

所以我们真正开辟的空间只有从Fib（N）到Fib（2）这一段，其他的调用函数，都是在重复利用栈空间的过程。

所以空间复杂度是O(N)

总结：时间是累积的，一去不复返
            空间是可以重复利用的。 

3.常见复杂度的对比

常数阶	O(1)	5201314
线性阶	O(N)	3N+1
平方阶	O(N^2)	2N^2 + 3N + 1
对数阶	O(logN)	3log(2)N + 2
NlogN阶	O(NlogN)	2N+3Nlog(2)N + 1
立方阶	O(N^3)	3N^3+2N^2+N+1
指数阶	O(2^N)	2^N

O(1)  <  O(log n)  <  O(n)  <  O(nlogn)  <  O(n^2)  <  O(n^3)  <  O(2^n)  <  O(n!)  <  O(n^n)