【数据结构】时间复杂度 | 空间复杂度 | 数据结构预备知识

「这是我参与2022首次更文挑战的第26天，活动详情查看：2022首次更文挑战」。

前言：

今年上半年更新的C语言系列教程《维生素C语言》在今年九月份已顺利完结，感谢大家的关注和支持！目前拟定主要更新C/C++方向的博客，次要更新Python和刷题题解。现在正式开启数据结构专栏，通过本人不断地输出，排版的美观性个人认为已经近乎完美了，尽可能最大限度地让读者在观看文章内容时引起极大舒适。此外，增添了黄色记号笔划重点部分，以图文并茂的形式进行展现内容，减少阅读的枯燥性。目前展现的排版我个人认为是比较满意的，本人将会继续改进，呈现出更多优质的博客给大家。

一、数据结构前言

0x00 何为数据结构

**【百度百科】**数据结构（Data Structure）是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。

📚 定义：数据结构（Data Structure）是计算机存储、组织数据的方式，指相互相之间存在一种或多种特定关系的数据元素的集合。

❓ 学习数据结构有什么意义？

🔑 数据结构就是有些项目在实现过程中，我们需要在内存中把数据存储起来：数组（虽然方便但是扩容比较麻烦）、链表（用指针链接起来）、树（查找）、哈希表……等等。

0x01 何为算法

**【百度百科】**算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

📚 定义：算法（Algorithm），即定义良好的计算过程，它取一个或一组的值输入，并产生出一个或一组的值作为输出。简单来说，算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

❓ 为什么要学习算法？

🔑 举个简单的例子：抖音的推荐算法，比如记录用户经常在哪个视频停留时间长从而进行分析，你经常看什么视频，它就会给你推送什么。不难看出，算法已经无处不在了。

0x02 学习建议

❓ 如何才能学好数据结构和算法？

💡

多读书少看报，少吃零食多睡觉

（bushi）。多敲代码多刷题，要注重画图和思考！等数据结构学习得差不多了，推荐刷《剑指offer》和《程序员代码面试指南》上的题：

👉 猛戳！剑指Offer【牛客网】

👉 猛戳！LeetCode【力扣官网】

二、算法效率

0x00 衡量算法好坏的方法

❓ 如何衡量一个算法的好坏？看代码是否简洁？

💬 比如对于以下斐波那契数列：

long long Fib(int n) {
    if (n < 3) {
        return 1;
    }
    return Fib(n - 1) + Fib(n - 2);
}

🤔 不难发现，斐波那契数列使用递归方式实现时代码非常简洁，但代码简洁就一定好吗？我们该如何去衡量他的好坏呢？让我们带着问题我们继续往下看。

0x01 算法的复杂度

📚 介绍：算法在编写成可执行程序后，运行时需要耗费 时间资源 和 空间资源（即内存资源）。因此，衡量一个算法的好坏一般是从 "时间" 和 "空间" 两个维度来衡量的，即时间复杂度和空间复杂度：

① 时间复杂度：主要衡量一个算法的运行快慢。

② 空间复杂度：主要衡量一个算法运行所需要的额外空间。

💡 须知：在计算机发展早期，计算机的存储容量很小，所以大家都很在乎空间复杂度。但是经过计算机行业的迅速发展，现在电脑内存越来越大了，内存也越来越便宜了。所以我们如今不再关注 "空间" ，已经不需要再特别关注一个算法的空间复杂度了。

摩尔定律（英特尔创始人之一戈登·摩尔的经验之谈）：其核心内容为，集成电路上可以容纳的晶体管数目在大约每经过18个月便会增加一倍。换言之，处理器的性能每隔两年翻一倍。它一定程度揭示了信息技术进步的速度，现代计算机发展就像开了挂一样地快。

👉 想了解猛戳：【百度百科】摩尔定律

🔺 注：复杂度在校招中的考察很多，校园招聘在笔试算法题和面试中都会考察对复杂度的计算和理解！此外，考研也是必考复杂度。

二、时间复杂度

0x00 时间复杂度的概念

📚 时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数（这里的函数时数学里的函数，数学里面带有未知数的函数表达式），它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上来说其实是不能算出来的，只有你把你的程序放在机器上跑起来才能知道耗费了多少时间。但是把每个算法都跑一遍是非常不现实的事，所以就产生了时间复杂度这样的分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

❓ 该如何计算时间复杂度呢？

🔑 简单来说就是：找到某条基本语句与问题规模 N 之间的数学表达式，就是算出了该算法的时间复杂度。

💬 例子：计算一下 Func1 中 ++count 语句总共执行了多少次？

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 执行的基本操作次数如下：

${\color{Magenta} F}({\color{Blue} N}) = {\color{Blue} N}^2 + 2*{\color{Blue} N} + 10$

N = 10 F(N) = 130

N = 100 F(N) = 10210

N = 1000 F(N) = 1002010

💡 N 越大，后两项对结果的影响就越小，所以我们也不需要精确的计算出结果，算个大概就可以了。所以这里我们将使用 大O渐进表示法 进行表示。

0x01 大O渐进表示法

**【百度百科】**大O符号（Big O notation）是用于描述函数渐进行为的数学符号。更确切地说，它是用另一个（通常更简单的）函数来描述一个函数数量级的渐近上界。在数学中，它一般用来刻画被截断的无穷级数尤其是渐近级数的剩余项。在计算机科学中，它在分析算法复杂性的方面非常有用。

📚 定义：大O符号是用于描述函数渐进性为的数学符号。

📚 推导大O阶方法：

① 用 常数1 取代运行时间中的所有加法常数。

② 在修改后的运行次数函数中，只保留最高阶项。

③ 如果最高阶 存在且不是1 ，则去除与这个项目相乘的常数。最后得到的结果就是大O阶。

🔑 使用大O渐进表示法后，Func1 的时间复杂度为

O(N^2)

：

${\color{Magenta} F}({\color{Blue} N}) = {\color{Blue} N}^2 + 2*{\color{Blue} N} + 10$

↓

${\color{Red} O}({\color{Blue} N}^2)$

N = 10 F(N) = 100

N = 100 F(N) = 10000

N = 1000 F(N) = 1000000

（看到大O就知道这里面的值不是准确的值，而是大概值）

📌 注意事项：

① 一般情况下，时间复杂度计算式未知数都是用的 N，但是也可以是 M、K、X 等等其他的，如果出现其他字母（非N）的情况情况我们可以这么表示：

如果 M 远大于 N →

O(M)

如果 N 远大于 M →

O(N)

M 和 N 差不多大 →

O(M + N)

②

O(1)

不是代表算法运行一次，而是 "常数次" 。

💡 通过上面的例子，我们发现大O渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

📚 另外有些算法的时间复杂度存在最好情况、平均情况、最坏情况：

① 最好情况：任意输入规模的最小运行次数（下界）
② 平均情况：任意输入规模的期望运行次数
③ 最坏情况：任意输入规模最大的运行次数（上界）

时间复杂度是一个悲观的预期，当一个算法随着输入不同、时间复杂度不同，做一个悲观的预期，看最坏的情况！

💬 例子：在一个长度为N的数组（下面例题中会出现，先提前讲个大概）

① 最好情况：1 次找到

② 最坏情况：N 次找到

③ 平均情况：N/2 次找到

📚 在实际中，一般情况下我们主要关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N) 。当然，这不是绝对的！比如希尔排序很少出现最坏的情况，所以有时候我们也会看平均情况。

0x02 时间复杂度计算的实例

💬 实例1：计算 Func2 的时间复杂度

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)

🔑 解析：基本操作执行了 2N+10 次，通过推导大O阶方法知道，时间复杂度为 O(N) 。因为当N越大，对10的影响就越小，所以+10省略。并且2N根据第三条规则（前面讲了），相乘时不是1时系数忽略，所以使用大O渐进法表示结果如下：

${\color{Magenta} F}({\color{Blue} N}) = 2{\color{Blue} N}+10$

↓

${\color{Red} O}({\color{Blue} N})$

我们带到题里再看一遍规则：

① 用常数1取代运行时间中的所有加法常数。

② 在修改后的运行次数函数中，只保留最高阶项。

③ 如果最高阶存在且不是1 ，则去除与这个项目相乘的常数。

❓ 为什么不算 ++k ？

🔑 我们不需要算的那么精确，我们只需要算循环的次数，指的是算法逻辑走了多少次，而不是程序走了多少条指令。所以我们不需要考虑 ++k 。

💬 实例2：计算 Func3 的时间复杂度

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(M+N）。一般情况下时间复杂度计算时未知数用的是N，但是也可以用其他未知数表示（前面讲过），所以使用大O渐进法表示结果如下：

${\color{Red} O}({\color{Blue} M}+{\color{Blue} N})$

为了加深印象，我们再看一遍：

一般情况下，时间复杂度计算式未知数都是用的 N，但是也可以是 M、K、X 等等其他的，如果出现其他字母（非N）的情况情况我们可以这么表示：

如果 M 远大于 N →

O(M)

如果 N 远大于 M →

O(N)

M 和 N 差不多大 →

O(M + N)

💬 实例3：计算 Func4 的时间复杂度

void Func4(int N) {
    int count = 0;
    for (int k = 0; k < 100; ++ k) {
        ++count;
    }

    printf("%d\n", count);
}

💡 答案：

O(1)

🔑 解析：基本操作执行了10次，通过推到大N阶的方法，时间复杂度为O(1) 。值得注意的是，这里的 "1" 是常数次而不是代表算法运行1次。所以使用大O渐进法表示结果如下：

${\color{Magenta} F}({\color{Blue} N}) = 100$

↓

${\color{Red} O}(1)$

💬 实例4：计算 strchr 的时间复杂度

// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character );

💡 答案：

O(N)

🔑 解析：基本操作执行最好1次，最坏N次。因为时间复杂度一般取最坏，所以时间复杂度为O(N) 。使用大O渐进法表示结果如下：

$worst: {\color{Magenta} F}({\color{Blue} N}) = ({\color{Blue} N}/2)$

↓

${\color{Red} O}({\color{Blue} N})$

💬 实例5：计算 BubbleSort 的时间复杂度

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次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2) 。冒泡排序，前一个比后一个大就交换。这两个循环虽然嵌套在一起，但是里面的循环不是n，外面的循环也不是n，而是end，它是在变化的。{ N-1 N-2 N-3 ... 1 } ，所以他是个等差数列，使用大O渐进法表示结果如下：

${\color{Magenta} F}({\color{Blue} N})={\color{Blue} N}*({\color{Blue} N}-1)/2$

↓

${\color{Red} O}({\color{Blue} N}^2)$

💬 实例6：计算 BinarySearch 的时间复杂度

int BinarySearch(int* a, int n, int x) {
    assert(a);
    int begin = 0;
    int end = n - 1;
    while (begin < end) {
        int mid = begin + ((end-begin) >> 1);
        if (a[mid] < x)
            begin = mid + 1;
        else if (a[mid] > x)
            end = mid;
        else
            return mid;
    }

    return -1;
}

💡 答案：

O(logN)

🔑 解析：基本操作执行最好1次，最坏O(logN)次，时间复杂度为O(logN）。使用大O渐进法表示结果如下：

${\color{Red} O}(log{\color{Blue} N})$

❓ 记不得log是什么了？log是对数：

在这里，我不得不吹一下二分查找了，真的是个非常牛掰的算法！

N个数中查找大概查找次数

1000 10

100W 20

1亿 30

......

在中国14亿人口中查找一个人，最多只要31次就可以了！当然，二分查找查找对象前提是有序的。

💬 实例7：计算递归版阶乘 Fac 的时间复杂度

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

💡 答案：

O(N)

🔑 解析：通过计算分析发现基本操作递归了N次，时间复杂度为O(N) 。使用大O渐进法表示结果如下：

${\color{Red} O}({\color{Blue} N})$

📚 递归算法：递归次数 * 每次递归调用次数

💬 实例8：计算递归版斐波那契数 Fib 的时间复杂度

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

💡 答案：

O(2^N)

🔑 解析：通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2^N) 。使用大O渐进法表示结果如下：

${\color{Red} O}(2^{\color{Blue} N})$

三、空间复杂度

0x00 空间复杂度的概念

📚 空间复杂度的定义：空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度并不是程序占用了多少bytes的空间，前面在介绍算法复杂度的时候就提到了如今我们已经不再关注 "空间" ，所以关注程序占用多少byte的空间是没有太大意义的。空间复杂度算的是变量的个数！此外，空间复杂度的计算规则基本和时间复杂度没有什么区别，同样也使用 大O渐进表示法。

📌 注意事项：函数运行时所需要的栈空间（即存储参数、局部变量和一些寄存器信息等）在编译期间就已经确定好了，因此空间复杂度主要是通过函数在运行的时候显式申请的额外空间来决定。

0x01 时间复杂度计算的实例

💬 实例1：计算 BubbleSort 的空间复杂度

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(1)

🔑 解析：使用了常数个额外空间，所以空间复杂度为 O(1) 。

${\color{Red} O}(1)$

💬 实例2：计算 Fibonacci 的空间复杂度

// 返回斐波那契数列的前n项
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;
}

💡 答案：

O(N)

🔑解析：malloc 动态开辟了N个空间，空间复杂度为 O(N)

${\color{Red} O}({\color{Blue} N})$

💬 实例3：计算递归版阶乘 Fac 的空间复杂度

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

💡 答案：

O(N)

🔑 解析：递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N) 。

${\color{Red} O}({\color{Blue} N})$

四、常见复杂度对比

0x00 常见的复杂度

一般算法常见复杂度表

92366

${\color{Red} O}(1)$

常数阶

3N+4

${\color{Red} O}({\color{Blue} N})$

线性阶

3N^2+4N+5

${\color{Red} O}({\color{Blue} N}^2)$

平方阶

3log(2)n+4

${\color{Red} O}(log{\color{Blue} N})$

对数阶

2n+3nlog(2)n+14

${\color{Red} O}({\color{Blue} N}log{\color{Blue} N})$

nlogn阶

n^3+2n^2+4n+6

${\color{Red} O}({\color{Blue} N}^3)$

立方阶

2^N

${\color{Red} O}(2^{\color{Blue} N})$

指数阶

【数据结构】时间复杂度 | 空间复杂度 | 数据结构预备知识

前言：

一、数据结构前言

0x00 何为数据结构

0x01 何为算法

0x02 学习建议

二、算法效率

0x00 衡量算法好坏的方法

0x01 算法的复杂度

二、时间复杂度

0x00 时间复杂度的概念

0x01 大O渐进表示法

0x02 时间复杂度计算的实例

三、空间复杂度

0x00 空间复杂度的概念

0x01 时间复杂度计算的实例

四、常见复杂度对比

0x00 常见的复杂度

0x01 大O对比图