时间复杂度

时间复杂度（Time Complexity）

时间复杂度是计算机科学中用于描述算法效率的一种度量方式。具体而言，它用于估计在最坏、最好或平均情况下，算法需要多长时间来处理输入数据并输出结果。

时间复杂度通常用大O记法（Big O notation）来表示。

1. 常数时间（Constant Time）: O(1)

• 描述：不论输入多大，算法的运行时间始终是一个常数。
• 例子：
  • 数组索引访问
  • 哈希表的插入和查找（理论上）

arr大小为n，但索引与n的大小无关，所以是O(1)。

数组索引（起始地址 + 索引×元素大小）直接定位到任何一个特定的数组元素，而不需要遍历数组，所以是O(1)，而链表中查找一个元素通常是 O(n)。

2. 对数时间（Logarithmic Time）: O(log n)

• 描述：每次算法的一次迭代都会大幅减少问题的规模。
• 例子：
  • 二分查找

  # 二分查找
  int binarySearch(int arr[], int target) {
      int left = 0, right = arr.length - 1;
      while (left <= right) {
          int mid = left + (right - left) / 2;
          if (arr[mid] == target) return mid;
          if (arr[mid] < target) left = mid + 1;
          else right = mid - 1;
      }
      return -1;
  }

给定一个数字 n，每次都把它除以 2。需要进行多少次这样的操作才能把 n 减小到 1？

- 第一次操作后，n 变成 n/2
- 第二次操作后，n 变成 n/4
- 第三次操作后，n 变成 n/8
- ···
- 第 k 次操作后，(n) 变成 n/2^k

当 n/2^k = 1 时，我们停止操作。解这个方程，我们得到 k = log_2 n。
因此，这个过程需要 log_2 n 次操作。

在实际应用中，底数 2 通常不是严格要求的——任何固定底数的对数函数（如 (log_2 n)、(log_10 n) 等）在大 (O) 记号下都是等价的。
所以通常简写为 O(log n)。

3. 线性时间（Linear Time）: O(n)

• 描述：算法的运行时间与输入大小成正比。
• 例子：
  • 简单查找
  • 遍历数组或列表

  for(int i = 0; i < n; i++) {
      // 常数时间操作
  }

执行了n次，所以是 O(n)。

4. 线性对数时间（Linear-Logarithmic Time）: O(n log n)

• 描述：有些排序算法（如快速排序、归并排序）具有这种时间复杂度。
• 例子：
  • 快速排序
  • 归并排序

  void mergeSort(int arr[], int left, int right) {
      if (left < right) {
          int mid = (left + right) / 2;
          mergeSort(arr, left, mid);
          mergeSort(arr, mid + 1, right);
          merge(arr, left, mid, right);
      }
  }

第一层：
n
第二层：
n/2+n/2=n
第三层：
n/4+n/4+n/4+n/4=n
...

每一层的工作量是 n，树的高度是 log n，执行次数为 n * log n。
所以总的时间复杂度是 O(n log n)。

5. 平方时间（Quadratic Time）: O(n^2)

• 描述：算法的运行时间与输入大小的平方成正比。
• 例子：
  • 冒泡排序
  • 插入排序

  for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) {
          // 常数时间操作
      }
  }

执行了 n * n 次，所以是 O(n^2)。

6. 立方时间（Cubic Time）: O(n^3)

• 描述：算法的运行时间与输入大小的立方成正比。
• 例子：
  • 矩阵乘法（简单实现）

  for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) {
          for(int k = 0; k < n; k++) {
              // 常数时间操作
          }
      }
  }

执行了 n * n * n 次，所以是 O(n^3)。

7. 指数时间（Exponential Time）: O(2^n)

• 描述：这类算法在处理大规模数据时效率非常低。
• 例子：
  • 斐波那契数列的递归实现

  int fibonacci(int n) {
      if (n <= 1) return n;
      return fibonacci(n - 1) + fibonacci(n - 2);
  }

执行的次数为：2^0 + 2^1 + ··· + 2^n 
根据等比数列求和公式 S = a * [1 - r^(n+1)] / (1 - r) 得：2^(n+1) - 1
简化为 O(2^n)

8. 阶乘时间（Factorial Time）: O(n!)

• 描述：这是效率最低的算法，仅用于非常小规模的问题。
• 例子：
  • 旅行商问题的暴力解法（尝试所有路径）