编辑“︁时间复杂度”︁

= 时间复杂度 =

时间复杂度（Time Complexity）是计算机科学中用于描述算法运行时间随输入规模增长而变化的度量方式。它帮助开发者分析算法效率，并比较不同算法在理论上的性能表现。时间复杂度通常用大O符号（Big O notation）表示，如<math>O(n)</math>、<math>O(n^2)</math>等。

== 基本概念 ==
时间复杂度关注的是算法执行时间与输入数据规模（通常记为<math>n</math>）之间的关系，而非具体的运行时间（如秒或毫秒）。它忽略常数因子和低阶项，专注于增长趋势。

=== 常见时间复杂度分类 ===
* '''常数时间''' <math>O(1)</math>：操作时间与输入规模无关。
* '''线性时间''' <math>O(n)</math>：操作时间与输入规模成正比。
* '''对数时间''' <math>O(\log n)</math>：操作时间随输入规模对数增长（如二分查找）。
* '''平方时间''' <math>O(n^2)</math>：操作时间与输入规模的平方成正比（如嵌套循环）。
* '''指数时间''' <math>O(2^n)</math>：操作时间随输入规模指数增长（如穷举搜索）。

== 代码示例 ==
=== 常数时间 <math>O(1)</math> ===
<syntaxhighlight lang="python">
def get_first_element(arr):
    return arr[0]  # 无论数组多大，直接访问第一个元素
</syntaxhighlight>
'''输入''': <code>arr = [5, 3, 9, 1]</code><br>
'''输出''': <code>5</code><br>
'''解释''': 访问数组固定位置的操作时间与数组长度无关。

=== 线性时间 <math>O(n)</math> ===
<syntaxhighlight lang="python">
def sum_array(arr):
    total = 0
    for num in arr:  # 遍历数组中的每个元素
        total += num
    return total
</syntaxhighlight>
'''输入''': <code>arr = [1, 2, 3, 4]</code><br>
'''输出''': <code>10</code><br>
'''解释''': 循环次数与数组长度成正比。

=== 平方时间 <math>O(n^2)</math> ===
<syntaxhighlight lang="python">
def find_duplicates(arr):
    duplicates = []
    for i in range(len(arr)):      # 外层循环
        for j in range(i + 1, len(arr)):  # 内层循环
            if arr[i] == arr[j]:
                duplicates.append(arr[i])
    return duplicates
</syntaxhighlight>
'''输入''': <code>arr = [2, 3, 2, 5, 3]</code><br>
'''输出''': <code>[2, 3]</code><br>
'''解释''': 嵌套循环导致操作次数为<math>n \times n</math>级别。

== 实际案例 ==
=== 搜索引擎的排序算法 ===
搜索引擎需要对数百万网页进行排序。若使用<math>O(n^2)</math>的冒泡排序，计算时间会随网页数量急剧增加；而改用<math>O(n \log n)</math>的快速排序或归并排序，能显著提升效率。

=== 数据库索引优化 ===
数据库使用B树（时间复杂度<math>O(\log n)</math>）作为索引结构，使得在海量数据中查找记录的时间远快于线性扫描（<math>O(n)</math>）。

== 可视化分析 ==
<mermaid>
graph LR
    A[O(1)] -->|最快| B[常数时间]
    C[O(log n)] -->|高效| D[对数时间]
    E[O(n)] -->|常见| F[线性时间]
    G[O(n log n)] -->|排序算法| H[线性对数时间]
    I[O(n²)] -->|避免| J[平方时间]
    K[O(2^n)] -->|不可行| L[指数时间]
</mermaid>

== 数学推导 ==
对于循环嵌套的算法，总时间复杂度可通过乘法规则计算：
<math>
T(n) = O(f(n)) \times O(g(n)) = O(f(n) \times g(n))
</math>

例如，两层嵌套循环的时间复杂度为：
<math>
T(n) = O(n) \times O(n) = O(n^2)
</math>

== 总结 ==
时间复杂度是算法设计的核心概念之一，帮助开发者：
# 预测算法在大规模数据下的表现。
# 选择最优算法解决特定问题。
# 避免编写效率低下的代码（如指数时间算法）。

理解并熟练应用时间复杂度分析，是成为优秀程序员的必经之路。

[[Category:计算机科学]]
[[Category:数据结构与算法]]
[[Category:算法基础]]