时间复杂度详解

最新推荐文章于 2024-09-16 12:36:03 发布

Volta_Hsu

最新推荐文章于 2024-09-16 12:36:03 发布

阅读量296

点赞数 6

分类专栏：数据结构文章标签：算法数据结构 c语言开发语言

本文链接：https://blog.csdn.net/volta_xu/article/details/139178588

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

时间复杂度详解

在数据结构中，时间复杂度是一个重要的概念。本文将详细探讨时间复杂度的概念及具体的计算方法。

1. 定义

时间复杂度（Time Complexity）描述的是一个算法在输入规模趋近无穷大时，其运行时间的增长趋势，通俗来讲就是指算法中所有语句>的频度（执行次数）之和，通常使用大O符号表示法，记作：T(n) = O(f(n))，其中n是问题的规模，f(n)是问题规模n的某个函数。

表示随着问题规模n 增大，算法执行时间的增长率和f(n)的增长率相同。

时间复杂度提供了一种定量的方式来衡量和比较不同算法之间的效率。

2. 常见时间复杂度

常见的时间复杂度从小到大排序如下：

常数时间复杂度：O(1)
对数时间复杂度：O(log n)
线性时间复杂度：O(n)
线性对数时间复杂度：O(n log n)
平方时间复杂度：O(n^2)
立方时间复杂度：O(n^3)
指数时间复杂度：O(2^n)
阶乘时间复杂度：O(n!)

具体描述

O(1): 算法的运行时间与输入规模无关，始终是一个常数。
O(log n): 算法的运行时间随着输入规模的增加以对数速率增长，常见于二分查找算法。
O(n): 算法的运行时间与输入规模成线性关系，常见于遍历算法。
O(n log n): 算法的运行时间是线性和对数的乘积，常见于高效的排序算法如归并排序、快速排序。
O(n^2): 算法的运行时间与输入规模的平方成正比，常见于简单的排序算法如冒泡排序、选择排序。
O(n^3): 算法的运行时间与输入规模的立方成正比，常见于某些三重嵌套循环的算法。
O(2^n): 算法的运行时间随着输入规模的增加呈指数增长，常见于解决某些NP问题的递归算法。
O(n!): 算法的运行时间随着输入规模的增加呈阶乘增长，常见于解决排列组合问题的暴力算法。

3. 计算方法

计算时间复杂度通常需要分析算法中基本操作的执行次数，然后找到一个表示这些次数的函数。再根据该函数的增长趋势，用大O符号表示其时间复杂度。

简化规则

在计算时间复杂度时，需要遵循以下简化规则：

忽略常数项：如O(n+1)简化为O(n)。
忽略低次项：如O(n^2+n)简化为O(n^2)。
忽略常数系数：如O(3n^2)简化为O(n^2)。

总而言之，就是去掉高次项系数和低此项。

例1：常数时间复杂度 O(1)

void example1(int n) {
    int a = n + 1;
}

无论输入 n 的值是多少，这段代码只执行一次加法操作，因此时间复杂度为O(1)。

例2：对数时间复杂度 O(log n)

void example2(int n) {
    int i = 1;
    while (i < n) {
        i = i * 2;
    }
}

每次循环 i 都会翻倍，因此循环次数为log2(n)，所以时间复杂度为O(log n)。

例3：线性时间复杂度 O(n)

void example3(int n) {
    for (int i = 0; i < n; i++) {
        printf("%d\n", i);
    }
}

循环体内的 printf 操作执行了 n 次，因此时间复杂度为O(n)。

例4：线性对数时间复杂度 O(n log n)

void example4(int n) {
    for (int i = 0; i < n; i++) {
        int j = 1;
        while (j < n) {
            j = j * 2;
        }
    }
}

外层循环执行 n 次，内层循环每次执行 log n 次，因此时间复杂度为O(n log n)。

例5：平方时间复杂度 O(n^2)

void example5(int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d, %d\n", i, j);
        }
    }
}

嵌套双重循环， printf 操作执行了 n * n 次，因此时间复杂度为O(n^2)。

例6：立方时间复杂度 O(n^3)

void example6(int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                printf("%d, %d, %d\n", i, j, k);
            }
        }
    }
}

嵌套三重循环， printf 操作执行了 n * n * n 次，因此时间复杂度为O(n^3)。

例7：指数时间复杂度 O(2^n)

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

这是计算斐波那契数列的递归算法，每个值的计算都依赖于前两个值的计算，因此时间复杂度为O(2^n)。

例8：阶乘时间复杂度 O(n!)

void example7(int n) {
    for (int i = 0; i < factorial(n); i++) {
        printf("%d\n", i);
    }
}

int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}