需要了解的时间复杂度、空间复杂度

最新推荐文章于 2024-04-11 09:53:31 发布

有机后浪

最新推荐文章于 2024-04-11 09:53:31 发布

阅读量1k

点赞数 1

分类专栏： JavaSE 数据结构和算法

本文链接：https://blog.csdn.net/key_768/article/details/104207874

版权

数据结构和算法同时被 2 个专栏收录

34 篇文章 2 订阅

订阅专栏

JavaSE

17 篇文章 2 订阅

订阅专栏

前言

运用不同算法涉及效率都是用算法复杂度：（时间复杂度、空间复杂度）来表示，具体是什么？

时间频度

时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)

当n较大时：1. 可以忽略常数项 2. 可以忽略低次项 3. 可以忽略系数

也就是T(n)=2n^2+3n+10 => T(n)=n^2

一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。
记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度

例：算法T(n)=2n^2+3n+10 => T(n)=n^2，设置辅助函数f(n)=n^2，该算法的时间复杂度为O(f(n))=O(n^2)

时间复杂度

算法的时间复杂度是一个函数，它定性描述该算法的运行时间

感觉时间复杂度就是执行算法所需的计算工作量，通常用O(f(n))表示
算法运行时间在不同的机器上会不同，所以时间复杂度只是简化的比较
常见的时间复杂度量级有：

常数阶O(1)
对数阶O(logn)
线性阶O(n)
线性对数阶O(nlogn)
平方阶O(n²)
立方阶O(n³)
K次方阶O(n^k)
指数阶(2ⁿ)

常数阶 O(1)

类似于这种不含变量循环等复杂结构的算法

        int i=0,j=1;
        int k=i++ + ++j;

无论有多少条语句，时间复杂度都算常数阶O(1)
为什么不是O(2)呢？O(f(n))表示法并不是用于来真实代表算法的执行时间的，它是用来表示代码执行时间的增长变化趋势的函数
即可以无论运行多少条语句，不是随着变量而变化，都简化为O(1)

对数阶 O(logn)

由于计算机使用二进制的记数系统，对数常常以2为底（即log₂n，有时写作 lgn ）。然而，由对数的换底公式，log_an和log_bn只有一个常数因子不同，这个因子在大O记法中被丢弃。因此记作O（logn），而不论对数的底是多少，是对数时间算法的标准记法

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

假设循环x次跳出循环，即2^x=n；x=log₂n，满足对数阶时间复杂度定义，这个算法的时间复杂度就是O(logn)

算法运行时间为log_an时间复杂度即为O(logn)

线性阶 O(n)

算法的运行时间与输入大小n为线性关系，就是线性阶时间复杂度

       for(int i=0;i<n;i++){
           int k=i;
       }

for循环就是最常见的线性阶算法，时间复杂度为O(n)

线性对数阶O(nlogn)

将线性阶的算法循环n编就是线性对数阶

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

平方阶O(n²)

明显O(n*n)就是平方阶

for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                
            }
        }

for循环嵌套for循环的时间复杂度就是O(n)
明显立方阶O(n³) 、K次方阶O(n^k)和平方阶相似
注意只保留最高阶的项，立方阶、k次方阶也要简化
O(n²/2+n/2) 简化为 O(n²)

指数阶(2ⁿ)

指数阶算法常常用于求出所以可能
例如n个集合有2ⁿ个子集，求所有子集
指数阶就是常数阶循环n次，与线性阶相似，但是复杂度大多了

效率： o(1) > o(log₂n)> o(n)> o(nlog₂n) > o(n²) > o(n³) > o(2ⁿ) > o(nⁿ)

空间复杂度

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))

空间复杂度就是看占据的存储空间

O(1)

临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，记为O(1)

int i=1,j=2;
int k=i+j;

不管要交换的数据多大，存储空间始终为固定数量
例如：冒泡排序

 int[] arr={1,5,8,2,6,0};
        int temp;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.print("第"+i+"轮排序后：");
            for(int a=0;a<6;a++) {
                System.out.print(arr[a]);
            }
            System.out.print("\n");
        }