时间复杂度

最新推荐文章于 2024-10-17 19:11:48 发布

守护ZAQ

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量425

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_47896744/article/details/121710479

版权

一、什么是时间复杂度

时间复杂度就是指执行算法所需的计算工作量

一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行的次数多，他花费的时间就多。一个算法中的执行语句次数被称为语句频度或者时间频度，即T（n）。

一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，即T（n），如果有某个辅助函数发f（n），使得当n趋近于无穷大时，T（n）/f(n)的极限数值为不等于零的常数，则称f(n)为T（n）的同数量级函数，即T（n）= O f（n），此时称O（f（n））为算法的渐进时间复杂度，也就是时间复杂度。

随着问题规模n的不断增大，上述的时间复杂度不断增大，算法的执行效率越低。

常用的时间复杂度按照耗费时间从大到小依次为

O(1)<O(logn)<O(n)<O(nlogn)<O(n²)<O(n³)<O(2ⁿ)<O(n!)

二、如何计算时间复杂度

1.常数阶

int sum = 0,n = 100; //执行一次  
  sum = (1+n)*n/2; //执行一次  
  System.out.println (sum); //执行一次

因为运行函数的次数与问题大小n的值并没有关系，所以这个算法的时间复杂度仍旧是O(1)，称为常数阶。

注意：常数项对函数的增长速度影响并不大，所以当 T(n) = c，c 为一个常数的时候，这个算法的时间复杂度为 O(1)；如果 T(n) 不等于一个常数项时，直接将常数项省略。

例如：T(n) = n + 29，此时时间复杂度为 O(n)

另外，因为高次项对于函数的增长速度的影响是最大的。比如n^3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的。同时因为要求的精度不高，所以直接忽略低此项。

比如:T(n) = n^3 + n^2 + 29，此时时间复杂度为 O(n^3)。

2.单个循环体的计算方法

对于一个循环，假设循环体的时间复杂度为 O(n)，循环次数为 m，则这个循环的时间复杂度为 O(n×m)。例如：

for(int i = 0; i < n; i++) {        // 循环次数为 n
        System.out.println("Hello, World!");  // 循环体时间复杂度为 O(1)
    }

此时时间复杂度为 O(n × 1)，即 O(n)。

3.多重循环体的计算方法

对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c...，则这个循环的时间复杂度为O(n×a×b×c...)。分析的时候应该由里向外分析这些循环。

for(int i = 0; i < n; i++) {                     // 循环次数为 n
        for(int j = 0; j < n; j++) {             // 循环次数为 n
            System.out.println("Hello, World!"); // 循环体时间复杂度为 O(1)
        }
    }

————————————————

此时时间复杂度为 O(n × n × 1)，即 O(n^2)。

4.多个时间复杂度计算方法

对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。

//第一部分时间复杂度为O(n^2)
for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            System.out.println("Hello, World!");
        }
    }
    // 第二部分时间复杂度为 O(n)
    for(int j = 0; j < n; j++) {
        System.out.println("Hello, World!");
    }

此时时间复杂度为 max(O(n^2)，O(n))，即 O(n^2)。

5.含有条件语句的计算方法

总的时间复杂度等于其中时间复杂度最大的路径的时间复杂度。

 if (n >= 0) {
        // 第一条路径时间复杂度为 O(n^2)
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                System.out.println("输入数据大于等于零");
            }
        }
    } else {
        // 第二条路径时间复杂度为 O(n)
        for(int j = 0; j < n; j++) {
            System.out.println("输入数据小于零");
        }
    }

时间复杂度为 max(O(n^2), O(n))，即 O(n^2)。

时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。

三、几种常见的时间复杂度实例：

for(int i=0;i<n;i++){
... //复杂度为O(1)的算法
}

上面算法循环体中的代码执行了n次，因此时间复杂度为O(n)。

int number=1;
while(number<n){
number=number*2;
... //复杂度为O(1)的算法
}

随着number每次乘以2后，都会越来越接近n，当number不小于n时就会退出循环。假设循环的次数为X，则由2^x=n得出x=log₂n，因此得出这个算法的时间复杂度为O(logn)。

 for(int i=0;i<n;i++){   
      for(int j=0;j<n;i++){
         //复杂度为O(1)的算法
         ... 
      }
  }

内部为循环体循环次数为O(n)，现在经过外层循环n次，那么这段算法的时间复杂度则为O(n²)。

for(int i=0;i<n;i++){   
      for(int j=i;j<n;i++){
         //复杂度为O(1)的算法
         ... 
      }
  }

当i=0时，内循环执行了n次；i=1时内循环执行了n-1次，当i=n-1时执行了1次，总执行次数为：

n+(n-1)+(n-2)+(n-3)+……+1
=(n+1)+[(n-1)+2]+[(n-2)+3]+[(n-3)+4]+……
=(n+1)+(n+1)+(n+1)+(n+1)+……
=(n+1)n/2
=n(n+1)/2
=n²/2+n/2
只保留最高阶，因此保留n²/2。去掉和这个项的常数，则去掉1/2,所以这段代码的时间复杂度为O(n²)。

附：