数据结构算法的时间复杂度计算（两种规则加法原则+乘法原则）

pranaa

已于 2024-09-22 10:49:17 修改

阅读量715

点赞数 23

分类专栏：数据结构文章标签：算法数据结构

于 2024-09-22 10:37:23 首次发布

本文链接：https://blog.csdn.net/m0_61338837/article/details/142432876

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在分析时间复杂性时，加法和乘法原则是两个基本且重要的概念，它们分别用于处理算法中顺序执行和嵌套执行的代码段的时间复杂度计算。以下是对这两个原则的详细说明：

一、加法原则

定义：

加法原则适用于顺序执行的代码段。如果一个算法可以分解为几个顺序执行的部分，且每部分的时间复杂度分别为O(f(n))、O(g(n))等，则整个算法的时间复杂度为这些部分时间复杂度的和的最大值，但通常我们忽略低阶项和常数项，只保留最高阶项。

解释：

顺序执行：算法中的操作按照一定顺序依次执行，前一个操作的输出可能是后一个操作的输入，但每个操作都是独立完成的。
时间复杂度求和：将各个顺序执行部分的时间复杂度相加，但由于大O表示法只关注最高阶项，因此实际上我们只保留和中的最高阶项。
忽略低阶项和常数项：在使用大O表示法时，我们忽略时间复杂度表达式中的低阶项和常数项，因为它们对算法整体性能的影响相对较小。

示例：

假设算法A由两个部分组成，第一部分的时间复杂度为O(n)，第二部分的时间复杂度为O(n^2)。根据加法原则，算法A的整体时间复杂度为O(n^2)，因为O(n^2)是两者中的最高阶项。

python示例：

def function_addition_example(n):  
    # 第一个操作，时间复杂度为O(n)  
    for i in range(n):  
        # 假设这里有一些操作，其时间复杂度是常数时间O(1)  
        pass  
      
    # 第二个操作，时间复杂度也为O(n)（但在这个例子中，我们假设它是O(n/2)，但为了加法原则，我们仍将其视为O(n)）  
    for j in range(n // 2):  # 注意：这里我们实际上降低了时间复杂度，但按加法原则，我们仍考虑O(n)  
        # 假设这里也有一些操作，其时间复杂度是常数时间O(1)  
        pass  
      
    # 由于两个操作都是O(n)，所以整体时间复杂度也是O(n)（忽略低阶项）  
  
# 注意：虽然第二个循环是n/2，但在大O表示法中，我们仍将其视为O(n)，因为大O只关心最高阶项

Java示例：

在这个例子中，我们定义了一个方法additionExample，它按顺序执行两个操作，每个操作都通过循环来模拟其时间复杂度。第一个操作的时间复杂度是O(n)，第二个操作的时间复杂度也是O(n)（尽管在这个例子中，第二个循环迭代次数是n/2，但在大O表示法中，我们仍然将其视为O(n)）。

public class TimeComplexityAddition {  
    public static void additionExample(int n) {  
        // 第一个操作，时间复杂度为O(n)  
        for (int i = 0; i < n; i++) {  
            // 这里执行一些操作，时间复杂度为O(1)  
        }  
  
        // 第二个操作，时间复杂度理论上为O(n/2)，但在大O表示法中视为O(n)  
        for (int j = 0; j < n / 2; j++) {  
            // 这里也执行一些操作，时间复杂度为O(1)  
        }  
  
        // 由于两个操作都是O(n)，所以整体时间复杂度也是O(n)（忽略低阶项）  
    }  
  
    public static void main(String[] args) {  
        int n = 1000; // 示例输入  
        additionExample(n);  
        // 注意：这个方法没有返回任何值，也没有打印输出，它仅仅是为了演示时间复杂度的加法原则  
    }  
}

二、乘法原则

定义：

乘法原则适用于嵌套执行的代码段。如果一个算法中包含嵌套循环或递归调用等嵌套执行的代码段，且外层代码段的时间复杂度为O(f(n))，内层代码段的时间复杂度为O(g(n))，则整个嵌套执行部分的时间复杂度为两者时间复杂度的乘积，即O(f(n) * g(n))。

解释：

嵌套执行：算法中的某个操作（如循环或递归调用）内部还包含另一个或多个操作，这些内部操作需要在外部操作每次执行时都重复执行。
时间复杂度相乘：由于内层操作需要在外层操作的每一次迭代中都执行，因此整个嵌套执行部分的时间复杂度是内外两层操作时间复杂度的乘积。

示例：

假设算法B包含一个外层循环和一个内层循环，外层循环的时间复杂度为O(n)，内层循环的时间复杂度也为O(n)。根据乘法原则，整个嵌套循环部分的时间复杂度为O(n * n) = O(n^2)。

python示例：

def function_multiplication_example(n):  
    # 外层循环，时间复杂度为O(n)  
    for i in range(n):  
        # 内层循环，时间复杂度为O(n)（注意：这里的n与外层循环的n相同）  
        for j in range(n):  
            # 假设这里有一些操作，其时间复杂度是常数时间O(1)  
            pass  
      
    # 由于内层循环在外层循环的每一次迭代中都执行，因此整体时间复杂度为O(n * n) = O(n^2)  
  
# 这个例子清楚地展示了乘法原则的应用：嵌套循环导致的时间复杂度是外层循环和内层循环时间复杂度的乘积

Java示例：

在这个例子中，我们定义了一个方法multiplicationExample，它包含一个嵌套循环。外层循环的时间复杂度是O(n)，内层循环的时间复杂度也是O(n)，因此整体时间复杂度是O(n * n) = O(n^2)。

public class TimeComplexityMultiplication {  
    public static void multiplicationExample(int n) {  
        // 外层循环，时间复杂度为O(n)  
        for (int i = 0; i < n; i++) {  
            // 内层循环，时间复杂度为O(n)  
            for (int j = 0; j < n; j++) {  
                // 这里执行一些操作，时间复杂度为O(1)  
            }  
        }  
  
        // 由于内层循环在外层循环的每一次迭代中都执行，因此整体时间复杂度为O(n * n) = O(n^2)  
    }  
  
    public static void main(String[] args) {  
        int n = 100; // 示例输入，注意为了简化演示，这里使用了较小的n值  
        multiplicationExample(n);  
        // 注意：这个方法同样没有返回任何值，也没有打印输出，它仅仅是为了演示时间复杂度的乘法原则  
    }  
}