【CS.AL】算法复杂度分析 —— 渐进符号表示法

news2025/2/27 16:29:27

文章目录

- 1 概述
- 2 渐进符号详解
- - 2.1 大O符号（O）
  - 2.2 Ω符号（Ω）
  - 2.3 Θ符号（Θ）
  - 2.4 o符号（o）
  - 2.5 ω符号（ω）
- 3 具体例子
- - 3.1 插入排序（Insertion Sort）
  - 3.2 二叉搜索树（Binary Search Tree）

1000.01.CS.AL.1.3-算法基础-渐进符号表示法-Created: 2024-06-13.Thursday17:38

1 概述

渐进符号表示法用于描述算法的时间复杂度和空间复杂度，衡量算法的性能。它可以帮助我们分析和比较不同算法的效率，尤其是当输入规模变大时。常见的渐进符号包括大O符号（O）、Ω符号（Ω）、Θ符号（Θ）、o符号（o）和ω符号（ω）。

2 渐进符号详解

2.1 大O符号（O）

大O符号（Big O Notation） 用于描述算法在最坏情况下的时间复杂度或空间复杂度，表示在输入规模趋近无穷大时，算法的增长率上限。它帮助我们理解算法的效率上限。

定义：算法的时间复杂度为O(f(n))，如果存在正数c和n0，使得对所有n ≥ n0，算法的执行时间T(n)满足T(n) ≤ c * f(n)。

示例：

对于线性时间复杂度的算法，如简单的遍历数组，时间复杂度为O(n)。
对于二分查找算法，时间复杂度为O(log n)。

表示法：

O(1)：常数时间复杂度。
O(n)：线性时间复杂度。
O(n²)：平方时间复杂度。
O(log n)：对数时间复杂度。
O(n log n)：线性对数时间复杂度。

2.2 Ω符号（Ω）

Ω符号（Big Omega Notation） 用于描述算法在最好情况下的时间复杂度或空间复杂度，表示在输入规模趋近无穷大时，算法的增长率下限。它帮助我们理解算法的最低效率。

定义：算法的时间复杂度为Ω(f(n))，如果存在正数c和n0，使得对所有n ≥ n0，算法的执行时间T(n)满足T(n) ≥ c * f(n)。

示例：

对于二分查找算法，最好情况是在第一次比较时就找到目标元素，其时间复杂度为Ω(1)。
对于快速排序算法，最好情况是每次都能均匀地将数组分成两部分，其时间复杂度为Ω(n log n)。

表示法：

Ω(1)：常数时间复杂度。
Ω(n)：线性时间复杂度。
Ω(n²)：平方时间复杂度。

2.3 Θ符号（Θ）

Θ符号（Big Theta Notation） 用于描述算法在平均情况下的时间复杂度或空间复杂度，表示在输入规模趋近无穷大时，算法的增长率的紧确界限。它帮助我们理解算法的精确效率。

定义：算法的时间复杂度为Θ(f(n))，如果存在正数c1、c2和n0，使得对所有n ≥ n0，算法的执行时间T(n)满足c1 * f(n) ≤ T(n) ≤ c2 * f(n)。

示例：

对于简单的遍历数组，时间复杂度为Θ(n)。
对于快速排序算法，平均情况时间复杂度为Θ(n log n)。

表示法：

Θ(1)：常数时间复杂度。
Θ(n)：线性时间复杂度。
Θ(n²)：平方时间复杂度。

2.4 o符号（o）

o符号（Small o Notation） 用于描述算法的非渐进上界，表示在输入规模趋近无穷大时，算法的增长率严格小于某个函数。它帮助我们理解算法的上界，但并不包括等于的情况。

定义：算法的时间复杂度为o(f(n))，如果对于任意正数c，存在n0，使得对所有n ≥ n0，算法的执行时间T(n)满足T(n) < c * f(n)。

示例：

对于一个执行时间为2n的算法，它的时间复杂度为o(n²)。

表示法：

o(n)：小于线性时间复杂度。
o(n²)：小于平方时间复杂度。

2.5 ω符号（ω）

ω符号（Small omega Notation） 用于描述算法的非渐进下界，表示在输入规模趋近无穷大时，算法的增长率严格大于某个函数。它帮助我们理解算法的下界，但并不包括等于的情况。

定义：算法的时间复杂度为ω(f(n))，如果对于任意正数c，存在n0，使得对所有n ≥ n0，算法的执行时间T(n)满足T(n) > c * f(n)。

示例：

对于一个执行时间为n log n的算法，它的时间复杂度为ω(log n)。

表示法：

ω(1)：大于常数时间复杂度。
ω(n)：大于线性时间复杂度。
ω(log n)：大于对数时间复杂度。

3 具体例子

3.1 插入排序（Insertion Sort）

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;

        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

分析：

最坏情况：输入数组为降序，时间复杂度为O(n²)。
最好情况：输入数组为升序，时间复杂度为Ω(n)。
平均情况：时间复杂度为Θ(n²)。

3.2 二叉搜索树（Binary Search Tree）

struct Node {
    int data;
    Node* left;
    Node* right;
};

Node* search(Node* root, int key) {
    if (root == nullptr || root->data == key)
        return root;

    if (root->data < key)
        return search(root->right, key);

    return search(root->left, key);
}