【Python基础教程】3 . 算法的时间复杂度

在这里插入图片描述

🎈个人主页：豌豆射手^
🎉欢迎 👍点赞✍评论⭐收藏
🤗收录专栏：python基础教程
🤝希望本文对您有所裨益，如有不足之处，欢迎在评论区提出指正，让我们共同学习、交流进步！

专栏往期文章：

【Python基础教程】3 . 算法的时间复杂度

一算法时间复杂度的定义
二大O表示法及其意义
三时间复杂度与算法执行时间的关系
- 3.1 概念
- 3.2 类比
四常见算法的时间复杂度分析
- 4.1 常数时间复杂度（O(1))：
- 4.2 对数时间复杂度（O(logN))
- 4.3 **线性时间复杂度（O(N))**：
- 4.4 线性对数时间复杂度（O(NlogN)：
- 4.5 **平方时间复杂度（O(N²))**：
五如何计算算法的时间复杂度
- 5.1 计数基本操作的执行次数
- 5.2 忽略低阶项和常数项
- 5.3 保留最高阶项
六优化算法时间复杂度的策略
- 6.1 选择更高效的算法
- 6.2 减少嵌套循环的层数
- 6.3 利用数据结构优化
- 6.4 空间换时间的思想
总结

在这里插入图片描述

引言:

【Python基础教程】3. 算法的时间复杂度

一算法时间复杂度的定义

算法时间复杂度是一个用于评估算法执行效率的关键指标，它衡量了算法执行时间随输入数据规模增长而变化的趋势。

换句话说，算法时间复杂度反映了算法在解决不同规模问题时所需的基本操作次数或计算资源量。

在算法分析中，“不同规模问题”指的是算法所要处理的输入数据的数量或大小的变化。

这个规模可以是问题的维度、数据集的大小、需要处理的元素数量等，通常用n来表示。

基本操作是指算法中执行的最简单、最底层的单个步骤，如赋值、比较、算术运算等，算法的执行时间主要取决于这些基本操作的执行次数。

例如：

x = 5  
y = 10

一条语句就是一个基本操作，这里有两个基本操作

例如：

def linear_operation(lst):  
    operation_count = 0  
    for item in lst:  
        print(item)  
        operation_count += 1  
    print(f"Total operations: {operation_count}")  
  
# 示例：一个小列表  
small_list = [1, 2, 3, 4, 5]  
linear_operation(small_list)  
  
# 示例：一个大列表  
large_list = list(range(1, 1001))  # 1到1000的列表  
linear_operation(large_list)

在这个例子中，linear_operation 函数遍历列表中的每个元素并打印它，同时计数执行了多少次操作。无论是小列表还是大列表，操作次数都与列表的长度成正比，即时间复杂度是O(n)。

运行结果：

运行结果如下：

小列表示例运行结果：

1
2
3
4
5
Total operations: 5

大列表示例运行结果：
由于大列表包含1到1000的整数，如果直接打印出来会非常长，这里我只展示开始的几个数字和最后的总结信息：

1
2
3
...
(这里省略了很多数字)
...
998
999
1000
Total operations: 1000

在小列表的示例中，linear_operation 函数遍历了small_list中的每个元素（1到5），并打印了它们，然后统计了总的操作次数为5。

在大列表的示例中，函数遍历了large_list中的每个元素（从1到1000），并打印了它们。由于这个列表很长，输出结果会非常长，但总的操作次数是1000，正如最后的输出所显示的那样。

然而，直接计算算法的实际执行时间往往是不切实际的，因为它受到计算机性能、编程语言、编译器优化等多种因素的影响。

因此，我们更关注算法执行时间随输入数据规模（通常表示为n）增长的趋势，这就是算法时间复杂度所关注的核心问题。

“算法执行时间随输入数据规模（通常表示为n）增长的趋势”这句话的意思是指当输入数据的大小（即n的值）变化时，算法完成其任务所需的时间是如何变化的。这里的“趋势”是指一种普遍的、长期的或规律性的变化方向或模式。

具体来说，当我们说一个算法的时间复杂度是O(n)，这意味着当输入数据规模n翻倍时，算法的执行时间大致也会翻倍。

但如果时间复杂度是O(n^2)，那么当n翻倍时，执行时间大约会变为原来的四倍（因为2的平方是4）。类似地，O(log n)表示当n增大时，执行时间的增长相对较慢，而O(n log n)则表示执行时间的增长介于线性和平方之间。

需要注意的是，算法时间复杂度只是评价算法性能的一个方面，还需要综合考虑其他因素如空间复杂度、算法的正确性、易读性和健壮性等。

但在处理大规模数据时，时间复杂度通常成为决定算法性能的关键因素。

因此，在设计和选择算法时，我们需要仔细分析算法的时间复杂度，以便选择出最适合当前问题的算法。

综上所述，算法时间复杂度是一个用于评估算法执行效率的重要指标，它描述了算法执行时间随输入数据规模增长而变化的趋势。

通过分析和比较不同算法的时间复杂度，我们可以选择出最优的算法来解决实际问题。

二大O表示法及其意义

算法时间复杂度通常使用大O表示法（Big O notation）来描述。

大O表示法是一种特殊的算法表示法，它主要用来估算程序执行次数或所占用的存储空间，以此评估算法的时间复杂度和空间复杂度。

其核心在于描述算法执行时间或所需存储空间随输入数据规模增长而变化的趋势。

具体来说，大O表示法通常表示为O(f(n))，其中n是输入数据的规模，f(n)是某个函数。

它给出了算法执行时间的一个上界，即当n趋向于无穷大时，算法执行时间的最坏情况增长率，注意是增长率，而不是实际执行时间。

这种表示法忽略了实际执行时间中的低阶项和常数项，只保留了最高阶项，从而能够更简洁、更直观地描述算法的时间复杂度。

为什么可以忽略了实际执行时间中的低阶项和常数项呢？

这是因为低阶项和常数项在数据规模较大时，相对于最高阶项的影响会逐渐减小，因此它们对整体趋势的贡献较小。

例如：

假设我们有两个算法A和B，它们的时间复杂度分别是 $O(n^2 + n)$ 和 $O(n^2)$ 。这里的 $n^2$ 是最高阶项， $n$ 是低阶项。

为了比较这两个算法在数据规模增大时的性能差异，我们可以考虑执行时间随 $n$ 增长的趋势。

首先，我们考虑 $n = 10$ 的情况。

假设算法A每次操作耗时1单位时间，算法B每次操作耗时也是1单位时间。

对于算法A，执行时间为10^2 + 10 = 110单位时间。
对于算法B，执行时间为10^2 = 100单位时间。

此时，算法A比算法B多用了==10%==的时间。

接下来，我们考虑 $n = 100$ 的情况。

对于算法A，执行时间为100^2 + 100 = 10100单位时间。
对于算法B，执行时间为100^2 = 10000单位时间。

此时，算法A比算法B多用了1%。

再进一步，我们考虑 $n = 1000$ 的情况。

对于算法A，执行时间为1000^2 + 1000 = 1001000单位时间。
对于算法B，执行时间为1000^2 = 1000000单位时间。

此时，算法A比算法B多用了=0.1%+。

从这个例子中可以看出，随着n的增大，算法A中的低阶项n相对于最高阶项n^2的影响逐渐减小。

在 $n = 10$ 时，低阶项对总执行时间的贡献还相当显著（10%），但当 $n$ 增大到1000时，这个贡献已经变得非常小（0.1%）。

因此，在描述算法执行时间随数据规模增长的趋势时，我们通常可以忽略低阶项和常数项，因为它们对=-=整体趋势的贡献在数据规模较大时会变得非常小==。这就是为什么大O表示法只保留最高阶项的原因。

大O表示法的主要意义在于，它提供了一种方式来比较不同算法的效率，尤其是在处理大规模数据时。

通过比较不同算法的大O表示，我们可以选择出最适合当前问题的算法。

三时间复杂度与算法执行时间的关系

3.1 概念

时间复杂度与算法执行时间之间存在密切的关系，但这种关系并非简单的等价或直接对应。

首先，时间复杂度是计算机科学中用来描述算法运行时间的一个概念。它定性描述了算法执行时间随输入数据规模增长而变化的趋势，它是一种趋势！。

具体来说，时间复杂度通常用大O符号表示，关注的是输入数据规模n趋近于无穷大时的情况。

大O表示法并不考虑具体的执行时间，而是关注算法执行时间的增速，增速越慢代表算法越快。

算法执行时间则是指算法在实际运行过程中所消耗的时间，它受到多种因素的影响，包括软硬件环境、语句执行次数、语句执行时间等。

语句执行时间可以通过语句的重复执行次数和执行一次所需的时间来计算。执行时间并非精确值，而是通过估计语句的执行次数得到的。

综上所述，时间复杂度与算法执行时间的关系在于它们都是衡量算法性能的重要指标，但它们的侧重点和计算方法有所不同。

时间复杂度更关注算法执行时间的增速，而算法执行时间则更具体地反映了算法在实际运行中的耗时情况。

在设计和选择算法时，我们需要综合考虑这两个因素以及其他相关因素，以选择出最优的算法来解决实际问题。

3.2 类比

在现实生活中，我们可以将时间复杂度和算法执行时间的关系类比为完成一项任务所需的时间和任务规模的关系。

假设你是一名学生，需要完成一系列的数学练习题。

这些练习题按照难度和数量被分为不同的级别，每个级别包含了一定数量的题目。

你可以将每个级别的题目数量类比为算法输入数据的规模n，而将完成每个级别题目所需的时间类比为算法执行时间。

当你面对较低级别的题目时，由于题目数量较少，你可能很快就能完成，所需时间较短。

这相当于算法处理较小规模数据时的执行时间。

然而，随着题目级别的提高，题目数量逐渐增加，你需要花费更多的时间来解答这些题目。

这就像是算法处理更大规模数据时，执行时间也会相应增加。

在这个过程中，时间复杂度可以类比为你解答题目时采用的策略或方法。如果你采用了一种高效的解题策略，那么即使题目数量增加，你也能相对较快地完成。

这相当于算法具有较低的时间复杂度，即算法执行时间随输入数据规模增长的速度较慢。

相反，如果你采用的解题策略不够高效，那么完成题目所需的时间可能会随着题目数量的增加而急剧增加。

这就像是算法具有较高的时间复杂度，即算法执行时间随输入数据规模增长的速度较快。

通过这个类比，我们可以更好地理解时间复杂度和算法执行时间之间的关系。

就像完成数学练习题一样，我们总是希望找到一种高效的策略或方法，以便在有限的时间内完成更多的任务。

同样地，在设计和选择算法时，我们也应该关注算法的时间复杂度，以便选择出最优的算法来解决实际问题。

四常见算法的时间复杂度分析

算法的时间复杂度是用来评估算法执行时间随输入数据规模增长而变化的趋势的一个指标。常见的时间复杂度类别包括以下几种：

4.1 常数时间复杂度（O(1))：

常数时间复杂度（O(1)）表示无论输入数据的规模如何变化，算法的执行时间都是固定的。

换句话说，无论输入数据有多少个元素，执行该算法所需的基本操作次数始终是一个常数，不会随着输入规模的增长而增加。

这种时间复杂度是算法性能的理想情况，因为它意味着算法的执行时间不受输入数据量的影响。

然而，在实际应用中，能够达到常数时间复杂度的算法通常只针对某些特定问题或特定情况下的操作。

以下是一些具有常数时间复杂度的算法示例：

1. 访问数组或列表的单个元素：

如果你知道要访问的元素的索引，那么无论数组或列表有多大，访问该元素所需的时间都是常数。

这是因为访问数组或列表的单个元素通常是通过计算内存地址直接完成的，不依赖于列表的大小。

def get_element(arr, index):
    return arr[index]  # 访问数组的单个元素，时间复杂度为O(1)

2. 计算固定大小的数据结构的大小：

如果你有一个固定大小的数据结构（如固定大小的数组或元组），那么获取其大小的操作也是常数时间复杂度。

def get_size(fixed_array):
    return len(fixed_array)  # 获取固定大小数组的大小，时间复杂度为O(1)

3. 执行固定次数的操作：

如果你执行的算法步骤数量是固定的，不依赖于输入数据的规模，那么这也是常数时间复杂度。

def fixed_operations():
    x = 5
    y = 10
    z = x + y  # 执行固定次数的操作，时间复杂度为O(1)
    return z

需要注意的是，虽然上述示例展示了常数时间复杂度的算法，但在实际应用中，要达到真正的常数时间复杂度可能需要一些额外的条件或限制。

例如，在访问数组元素的例子中，我们必须知道要访问的元素的索引，并且该索引必须是有效的。如果索引是变量且依赖于输入数据规模，那么访问时间可能就不再是常数了。

此外，即使算法的主体部分具有常数时间复杂度，如果算法包含一些预处理或后处理步骤，这些步骤的时间复杂度可能不是常数，这会影响整个算法的整体时间复杂度。

因此，在分析算法时间复杂度时，需要综合考虑所有相关因素。

4.2 对数时间复杂度（O(logN))

对数时间复杂度（O(logN)）是算法时间复杂度的一个类别，它表示算法的执行时间随着输入数据规模N的对数增长而增长。

换句话说，当输入数据的规模翻倍时，算法所需的执行时间只会增加一个常数倍的对数时间。

这种时间复杂度通常出现在采用分治策略解决问题的算法中，尤其是那些可以将问题规模不断减半直到找到解决方案的算法。

以下是对数时间复杂度的一些具体特点和常见应用场景：

特点

快速增长的输入规模对应缓慢增长的执行时间：即使输入数据的规模N非常大，对数时间复杂度的算法也能在相对较短的时间内完成计算。
基于分治策略：对数时间复杂度的算法通常利用分治策略，将问题划分为规模更小的子问题，然后递归地解决这些子问题。
依赖于数据的特性：对数时间复杂度通常出现在数据具有某种特定结构或性质的情况下，如已排序的数组或平衡的二叉搜索树。

常见应用场景

二分查找：在已排序的数组中查找特定元素时，二分查找算法每次将搜索范围减半，直到找到目标元素或搜索范围为空。其时间复杂度为O(logN)，其中N是数组的长度。

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

平衡的二叉搜索树操作：在平衡的二叉搜索树（如AVL树、红黑树等）中进行插入、删除和查找操作时，由于树的高度与节点数量呈对数关系，因此这些操作的时间复杂度都是O(logN)，其中N是树中节点的数量。
堆操作：堆是一种特殊的完全二叉树，常用于实现优先队列。在堆上进行插入和删除元素（特别是删除堆顶元素并重新调整堆）的操作，时间复杂度也是O(logN)。

注意事项

对数时间复杂度通常是最优或接近最优的时间复杂度，特别是在处理大规模数据时。
实现对数时间复杂度的算法通常需要对数据进行预处理（如排序或构建平衡树），这些预处理步骤可能具有不同的时间复杂度。
在某些情况下，即使算法本身具有对数时间复杂度，但由于输入数据的特性或实现方式的不同，实际运行时间可能并不总是最优的。

对数时间复杂度是算法分析和设计中非常理想的时间复杂度类别，因为它允许算法在处理大规模数据时仍然保持高效的性能。

4.3 线性时间复杂度（O(N))：

线性时间复杂度（O(N)）是算法性能分析中的一个重要概念，它表示算法的执行时间随着输入数据规模N的线性增长而增长。换句话说，如果输入数据的规模翻倍，算法的执行时间也会大致翻倍。这种时间复杂度通常出现在需要遍历整个输入数据的算法中。

以下是线性时间复杂度的一些具体特点和常见应用场景：

特点

遍历整个数据集：算法需要访问或处理输入数据中的每一个元素一次且仅一次。
时间与输入规模成正比：算法的执行时间直接取决于输入数据的数量。如果输入数据规模翻倍，执行时间也会翻倍（不考虑其他常数因子）。
简单直观：线性时间复杂度的算法通常较为直观，因为它们通常涉及简单的循环或迭代操作。

常见应用场景

数组遍历：当需要遍历数组或列表中的每个元素以执行某些操作时，如计算总和、查找最大值或最小值等，算法的时间复杂度通常是O(N)。

def sum_of_elements(arr):
    total = 0
    for num in arr:  # 遍历数组中的每个元素
        total += num
    return total

链表遍历：在单链表或双链表中，为了访问每个节点或执行某些操作（如打印节点值、查找特定节点等），通常需要从头节点开始遍历整个链表，时间复杂度也是O(N)。
简单排序算法：某些简单的排序算法，如冒泡排序和选择排序，在最坏情况下的时间复杂度是O(N^2)，但它们在最好情况下的时间复杂度是O(N)。尽管这些算法在实际应用中不常用，但它们作为教学示例有助于理解线性时间复杂度的概念。

注意事项

线性时间复杂度是许多算法可以达到的最优时间复杂度之一，特别是在需要处理每个输入数据元素的情况下。
在某些情况下，通过优化算法或利用数据的特定结构，可能可以进一步降低时间复杂度。然而，在许多情况下，线性时间复杂度是处理整个数据集所必需的。
当处理大规模数据集时，即使算法具有线性时间复杂度，执行时间也可能很长。因此，在实际应用中，除了优化算法本身外，还需要考虑其他因素，如使用更高效的数据结构、并行处理或分布式计算等。

线性时间复杂度是算法设计和分析中的基本概念之一。许多实用的算法都具有线性时间复杂度，这使得它们能够高效地处理大规模数据集。

4.4 线性对数时间复杂度（O(NlogN)：

线性对数时间复杂度（O(NlogN)）是算法时间复杂度分析中的一个重要类别，它表示算法的执行时间随着输入数据规模N的增长而呈线性对数增长。这种时间复杂度通常出现在需要对数据进行排序、搜索或其他需要分治策略且涉及排序操作的算法中。

以下是线性对数时间复杂度的一些具体特点和常见应用场景：

特点

结合线性与对数增长：线性对数时间复杂度结合了线性增长（与N成正比）和对数增长（与logN成正比）的特点。当输入数据规模N增大时，执行时间不仅随N线性增长，还受到对数因素的影响。
通常涉及排序操作：许多具有线性对数时间复杂度的算法都涉及对输入数据进行排序的步骤。排序本身通常是一个O(NlogN)的操作，因此许多高级算法（如某些搜索算法和图形算法）的时间复杂度也会受到排序步骤的影响。
分治策略的应用：线性对数时间复杂度的算法经常采用分治策略，将问题划分为多个子问题，然后递归地解决这些子问题。归并排序和快速排序是这种策略的典型示例。

常见应用场景

归并排序：归并排序是一种采用分治策略的排序算法。它将数组分成两半，递归地对每半进行排序，然后将已排序的半部分合并成一个完整的排序数组。归并排序的时间复杂度是O(NlogN)，其中N是待排序元素的数量。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    merged = []
    left_index = right_index = 0
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            merged.append(left[left_index])
            left_index += 1
        else:
            merged.append(right[right_index])
            right_index += 1
    merged.extend(left[left_index:])
    merged.extend(right[right_index:])
    return merged

快速排序：快速排序是另一种采用分治策略的排序算法。它选择一个基准元素，将数组分为两部分，一部分包含比基准小的元素，另一部分包含比基准大的元素，然后递归地对这两部分进行排序。快速排序的平均时间复杂度是O(NlogN)，但在最坏情况下会退化到O(N^2)。
堆排序：堆排序利用堆这种数据结构进行排序。它首先构建一个大顶堆（或小顶堆），然后将堆顶元素与末尾元素交换，并调整堆结构以保持其性质。重复这个过程直到所有元素排序完毕。堆排序的时间复杂度也是O(NlogN)。
某些图算法：在某些图算法中，如Dijkstra算法（用于单源最短路径问题）和Prim算法（用于最小生成树问题），当使用优先队列（如二叉堆）来优化性能时，其时间复杂度也可以达到O(NlogN)。

注意事项

线性对数时间复杂度通常被认为是相对高效的，尤其是在处理大规模数据集时。它比平方时间复杂度（O(N^2)）或更高阶的时间复杂度要好得多。
在实际应用中，算法的实际运行时间可能受到多种因素的影响，包括输入数据的特性、硬件性能、实现方式等。因此，在分析算法性能时，除了考虑时间复杂度外，还需要综合考虑其他因素。

线性对数时间复杂度是许多高效算法所能达到的最优或接近最优的时间复杂度之一。通过优化算法和利用合适的数据结构，我们可以在处理大规模数据集时实现更高的性能。

4.5 平方时间复杂度（O(N²))：

平方时间复杂度（O(N²)）是算法时间复杂度分析中的一个类别，它表示算法的执行时间随着输入数据规模N的平方增长而增长。换句话说，如果输入数据的数量翻倍，算法所需的执行时间大约会变为原来的四倍。这种时间复杂度通常出现在需要比较或处理每对输入元素之间的关系的算法中。

以下是平方时间复杂度的一些具体特点和常见应用场景：

特点

每对元素之间的操作：平方时间复杂度的算法通常涉及对输入数据中的每对元素执行某种操作，如比较、配对或计算。
增长速度快：随着输入数据规模N的增加，平方时间复杂度的算法执行时间增长得非常快。对于大规模数据集，这种算法可能会变得非常低效。
直观易懂：由于平方时间复杂度的算法通常涉及嵌套循环，它们通常比较直观且易于理解。

常见应用场景

简单排序算法：冒泡排序和插入排序是两种典型的具有平方时间复杂度的排序算法。这些算法在每次迭代中比较相邻的元素，并根据需要交换它们的位置，直到整个数组排序完毕。对于包含N个元素的数组，冒泡排序和插入排序在最坏情况下的时间复杂度都是O(N²)。
暴力搜索算法：在某些情况下，可能需要使用暴力搜索算法来查找满足特定条件的元素或子序列。例如，在一个未排序的数组中查找两个数的和等于目标值的问题，可以使用嵌套循环遍历所有可能的数对，并检查它们的和是否等于目标值。这种暴力搜索算法的时间复杂度是O(N²)。
全矩阵乘法：在计算两个N×N矩阵的乘积时，如果使用简单的三重循环算法，时间复杂度将是O(N³)。虽然这不是平方时间复杂度，但它展示了当算法需要处理多维数据或每对元素之间的操作时，时间复杂度可能会迅速增加。

注意事项

平方时间复杂度通常被认为是效率较低的，特别是在处理大规模数据集时。因此，在实际应用中，应尽量避免使用具有平方时间复杂度的算法，除非没有其他更高效的解决方案。
在某些情况下，可以通过优化算法或使用更高级的数据结构来降低时间复杂度。例如，使用快速排序或归并排序等高效的排序算法可以将排序操作的时间复杂度降低到O(NlogN)。
在分析算法性能时，除了考虑时间复杂度外，还需要综合考虑其他因素，如空间复杂度、实现难度和算法的稳定性等。

总之，平方时间复杂度是算法性能分析中的一个重要概念，它提醒我们在设计算法时要注意避免不必要的比较和配对操作，以提高算法的效率。

此外，还有指数时间复杂度（O(2^N)）、阶乘时间复杂度（O(N!)）等更为复杂的时间复杂度类别，这些通常出现在解决某些特定问题时，比如旅行商问题（TSP）等。

需要注意的是，这里的N通常代表输入数据的规模或问题的大小。时间复杂度的表示方法（大O表示法）关注的是算法执行时间的增长率，而不是具体的执行时间。因此，在实际应用中，我们需要根据问题的规模和需求来选择合适的算法，以达到最优的性能。