算法复杂度分析

最新推荐文章于 2024-09-20 15:09:03 发布

不想debug了

最新推荐文章于 2024-09-20 15:09:03 发布

阅读量1.3k

点赞数 44

文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/weixin_53094999/article/details/136330381

版权

本文详细介绍了时间复杂度分析的概念，如何通过大O表示法评估代码执行时间和空间复杂度，以及常见复杂度类型如O(1),O(logn),O(n),O(n^2)的应用实例。同时，文章强调了算法复杂度在代码优化和评判中的重要性。

摘要由CSDN通过智能技术生成

一、为何分析

1. 指导你编写出性能更优的代码。

2. 评判别人写的代码的好坏。

二、时间复杂度分析

1.时间复杂度

时间复杂度分析：来评估代码的执行耗时的。

    public int sum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum = sum + i;
        }
        return sum;
    }

1. 假如每行代码的执行耗时一样：1ms。

2. 分析这段代码总执行多少行？可以分析这段代码，其中int sum=0,int i=1,return sum,这三行代码是只会执行一次，但是由于变量n的不确定，所以这三行代码i<=n,i++,sum=sum+i,会导致循环的次数不同，所以是执行3n次。

3. 代码耗时总时间： T(n) = (3n + 3) * 1ms。

2.大O表示法

1. 大O表示法：不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势。

2. T(n)与代码的执行次数成正比(代码行数越多，执行时间越长)。

3. 当n很大时，公式中的低阶，常量，系数三部分并不左右其增长趋势，因此可以忽略，我们只需要记录一个最大的量级就可以了。

所以，最后表示上面代码的时间复杂度是O(n)。

3.常见复杂度表示形式

速记口诀：常对幂指阶。

4.例题

（1）常数

    public int test01(int n) {
        int i = 0;
        int j = 1;
        return i + j;
    }

    public void test02(int n) {
        int i = 0;
        int sum = 0;
        for (; i < 100; i++) {
            sum = sum + i;
        }
        System.out.println(sum);
    }

test01函数中的n并不会影响代码执行次数，也就是执行3次，所以就是O(1)。test02函数中，循环的次数是固定的，并没有因为n而变化，所以也是O(1)。

总结：只要代码的执行时间不随着n的增大而增大，这样的代码复杂度都是O(1)。

（2）对数

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

    public void test04(int n) {
        int i = 1;
        while (i <= n) {
            i = i * 10;
        }
    }

test03函数中因为i会变化，所以执行的次数是由i和n一起决定的，i=n时就是执行的最后一次。我们给出如下图所示，可以得出 $2^{x}=n$ ，x代表执行的次数，所以可以得出 $x=\log_{2}n$ ,由以上分析可知，代码的时间复杂度表示为O( $\log n$ )。test04也是一样，只是底数不同，但是表示的都是一样是O( $\log n$ )。

（3）幂数

    public int sum1(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum = sum + i;
        }
        return sum;
    }

    public int sum2(int n) {
        int sum = 0;
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= n; ++j) {
                sum = sum + i * j;
            }
        }
        return sum;
    }

前面最开始的例题讲解过，sum1时间复杂度也就是O(n)，sum2由于是双重循环，并且循环的次数都与n有关，得出O( $3n^{2}+3n$ )，由于主要是受高阶影响，所以是O( $n^{2}$ )。

（4）线性对数

    public void test05(int n) {
        int i = 0;
        for (; i <= n; i++) {
            test06(n);
        }
    }

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

由前面的题目可以知道，test06时间复杂度是O( $\log n$ )。由于test05函数中的test06(n)是在循环体里面，所以test05时间复杂度就是两者相乘，所以是O( $n\log n$ )。

三、空间复杂度

空间复杂度全称是渐进空间复杂度，表示算法占用的额外存储空间与数据规模之间的增长关系。

    public void test(int n) {
        int i = 0;
        int sum = 0;
        for (; i < n; i++) {
            sum = sum + i;
        }
        System.out.println(sum);
    }


    public void print(int n) {
        int i = 0;
        int[] a = new int[n];
        for (i; i < n; ++i) {
            a[i] = i * i;
        }
        for (i = n - 1; i >= 0; --i) {
            System.out.println(a[i]);
        }
    }

test函数sum变量已经定义好了4个字节，不会在变了，所以空间复杂度是O(1)。

print函数定义了a数组，但是数组的大小是由n决定的，所以空间复杂度是O(n)。

我们常见的空间复杂度就是O(1),O(n),O(n ^2)，其他像对数阶的复杂度几乎用不到，因此空间复杂度比时间复杂度分析要简单的多。