时间复杂度概念

时间复杂度：衡量算法随着输入量增长，执行时间的增长速度。

一般来说，肯定是希望时间复杂度小点比较好。

常见的时间复杂度

常见的时间复杂度包括：

1. 常数时间$O(1)$
2. 线性时间$O(n)$
3. 对数时间$O(logn)$
4. 平方时间$O(n^2)$
5. ……

时间复杂度的衡量

时间复杂度的衡量：算法中基本操作的执行次数。

时间复杂度=$O(x)$，x为程序运行计算次数

• 在算法分析中，基本操作是指算法执行过程中最简单、不可再分解的操作。这些操作通常具有以下特点：

  • 原子性：基本操作是不可分割的，即它在执行时不会被其他操作中断。
  • 简单性：基本操作通常非常简单，如赋值、比较、算术运算等。
  • 重复性：在算法执行过程中，基本操作会被重复执行多次。

• 在衡量时间复杂度时，一般估算其最坏情况下的数量级，而不是具体的数字。

• 如果存在多项时间复杂度，取最高项。

  • O(n^2+n)=O(n^2)
  • O(n+6)=O(n)
  • O(n^3+n+10)=O(n^3)

在做题的时候会关注到如下限制：

语言	最大运行时间	最大运行内存
C++	1s	256M
C	1s	256M
Java	2s	256M
Python3	3s	256M
PyPy3	3s	256M
Go	3s	256M
JavaScript	3s	256M

一般来说，评测机1s可以运行2e8次运算，为了不超时，尽量把运算规模控制在1e8之内。

常数时间例子

常数时间复杂度（O(1)）意味着算法的运行时间与输入数据的大小无关，无论输入数据有多大，算法的执行时间都保持不变。这通常发生在算法只执行固定数量的操作时。

python">def add(x, y):return x + y

线性时间例子

线性时间复杂度（O(n)）意味着算法的运行时间与输入数据的大小成正比。对于长度为n的输入，算法的执行时间大致是n的倍数。在Python中，很多基本的迭代操作都具有线性时间复杂度。

python"># 遍历列表中的所有元素：
def print_elements(lst):for element in lst:print(element)

python"># 计算最大公约数（GCD）：
# 使用欧几里得算法计算两个数的最大公约数，该算法基于递归，每次将问题规模减半。def gcd(a, b):if b == 0:return aelse:return gcd(b, a % b)

python"># 快速幂算法：
# 快速幂算法用于计算a^b的值，通过将指数分解为2的幂次，每次迭代减少问题的规模。def fast_power(a, b):if b == 0:return 1elif b % 2 == 0:return fast_power(a, b // 2) ** 2else:return a * fast_power(a, b // 2) ** 2

python"># 归并排序中的分割步骤：
# 归并排序是一种分治算法，其中分割步骤的时间复杂度是O(log n)。def merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2L = arr[:mid]R = arr[mid:]merge_sort(L)merge_sort(R)i = j = k = 0while i < len(L) and j < len(R):if L[i] < R[j]:arr[k] = L[i]i += 1else:arr[k] = R[j]j += 1k += 1while i < len(L):arr[k] = L[i]i += 1k += 1while j < len(R):arr[k] = R[j]j += 1k += 1

python"># 堆排序中的堆调整：
# 堆调整是堆排序算法中的关键步骤，用于保持堆的性质，其时间复杂度为O(log n)。def heapify(arr, n, i):largest = il = 2 * i + 1r = 2 * i + 2if l < n and arr[largest] < arr[l]:largest = lif r < n and arr[largest] < arr[r]:largest = rif largest != i:arr[i], arr[largest] = arr[largest], arr[i]heapify(arr, n, largest)

平方时间例子

平方时间复杂度（O(n^2)）通常出现在需要对数据集中的每个元素进行多次操作的算法中。这种复杂度意味着算法的运行时间与输入数据大小的平方成正比。

python"># 冒泡排序：
# 冒泡排序通过重复遍历列表，比较并交换相邻元素来排序，每次遍历都减少未排序部分的长度。def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]

python"># 选择排序：
# 选择排序通过不断选择剩余部分的最小元素并将其放置在正确的位置。def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]

python"># 插入排序：
# 插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >= 0 and key < arr[j]:arr[j + 1] = arr[j]j -= 1arr[j + 1] = key

python"># 计算两个字符串的最长公共子序列（LCS）：
# 通过动态规划计算两个字符串的最长公共子序列的长度，时间复杂度为O(n^2)。def lcs(s1, s2):m = len(s1)n = len(s2)dp = [[0] * (n+1) for _ in range(m+1)]for i in range(1, m+1):for j in range(1, n+1):if s1[i-1] == s2[j-1]:dp[i][j] = dp[i-1][j-1] + 1else:dp[i][j] = max(dp[i-1][j], dp[i][j-1])return dp[m][n]

对数时间例子

对数时间复杂度（O(log n)）通常出现在涉及二分搜索或类似分治策略的算法中。这种复杂度意味着算法的运行时间与输入数据的大小的对数成正比。

python"># 二分搜索：
# 二分搜索是一种在有序数组中查找特定元素的算法。它每次将搜索范围减半，因此搜索时间是输入数组长度的对数。def binary_search(arr, low, high, x):if high >= low:mid = (high + low) // 2if arr[mid] == x:return midelif arr[mid] > x:return binary_search(arr, low, mid - 1, x)else:return binary_search(arr, mid + 1, high, x)else:return -1