算法复杂度

小咪咪 2021-09-30 06:40 364阅读 0赞

算法复杂度分为  ‘时间复杂度’  和  ‘空间复杂度’  。

其作用： 时间复杂度是指执行算法所需要的计算工作量；

空间复杂度是指执行这个算法所需要的内存空间。（算法的复杂性体现在运行该算法时的计算机所需资源的多少上，计算机资源最重要的是时间和空间（即寄存器）资源，因此复杂度分为时间和空间复杂度）。

那么怎么理解>>>时间复杂度:

（我的理解是在运行一个算法所需要的时间长短，时间长时间复杂度大，时间短，时间复杂度小。

但是往往我们并不能一个算法一个算法的测试时间复杂度，所以只需要估算一个大致的时间就行了，把你需要估算的算法取到极限，那么就很容易估算出来了）

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

分析：随着模块n的增大，算法执行的时间的增长率和 f(n) 的增长率成正比，所以 f(n) 越小，算法的时间复杂度越低，算法的效率越高。

分类：

按数量级递增排列，常见的时间复杂度有：

常数阶O(1),

对数阶O(  ![e850352ac65c1038d0ae2312b4119313b17e890a.jpg][] ),

线性阶O(n),

线性对数阶O(nlog2n),

平方阶O(n^2)，

*立方阶O(n^3),...，*

k次方阶O(n^k),指数阶O(2^n)。

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

例子：(加上自己的理解)

def func () {
      # 这里寄存器接收到了两条执行指令，每条时间复杂度为O(1),但是这里时间复杂度还是O(1)，
    　# 因为可以理解为两个常量，常量的时间复杂度为O(1)
      print('hello,world!' )
      return 0     
    }

def func () {
        for i in range(n):   # 这里n是一个整型，循环次数为n
             print('n')    # 循环体时间复杂度为O(1)
    } 
    # 所以这里一共需要2n次运算，时间复杂度为O(n x 2)，既O(n)

def func(){
        for i in range(n):    # 循环次数为n
            for j in range(n):    # 循环次数为n
                print('hello,world!')    # 循环体时间复杂度为O(1)
    }
    # 此时时间复杂度为O(n x n x 1)，既O(n^2)

# 对于顺序执行的语句或者算法，时间复杂度等于其中最大的时间复杂度。
    def func(){
        # 第一块的时间复杂度为O(n^2)
        for i in range(n):
            for j in range(j):
                print('hello,world!')
        # 第二块的时间复杂度为O(n)
        for i in range(n):
            print('hello,world!')  
    }
    # 所以这个函数或者算法的时间复杂度为O(n^2)
    # 这个规则对于if -- else 判断语句同样生效

def func(){
        num = 2
        while n:
            num *= 2        
            print(num)
            if i < n:
                break
    }
    # 这个可以看出来这是一个指数函数,循环条件满足 2^t < n  才会退出
    # 可以得出，执行次数t = log(2)(n)，即 T(n) = log(2)(n)
    # 可见时间复杂度为 O(log(2)(n))，即 O(log n)。

def func(){
        if n <= 1:
            return 1
        else:
            return func(n - 1) + func(n - 2)
    }
    # 这个是不是看着很眼熟，可以参考斐波那契数列的例子，因为这是一个斐波那契数列
    # 然后，然后，我之前看别人解释的这个题目有点懵，然后我自己想了想，
    # 这个数列就像是一个完全二叉树，他的每个节点下面都有两个节点，考虑完全二叉树的的总结点数公式是(2^n  -  1)
    # 就直接求出来这个算法的时间复杂度了O(2^n  -  1),既O(2^n)

当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。

如果算法的执行时间不随着问题规模n的增长而增加，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)

空间复杂度：

类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)S(n)定义为该算法所耗费的存储空间，它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。  
　　**空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。**一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，我们称这种算法是“就地\\"进行的，是节省存储的算法；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如将在第九章介绍的快速排序和归并排序算法就属于这种情况。

转载于:https://www.cnblogs.com/zpstu/p/10150600.html

[e850352ac65c1038d0ae2312b4119313b17e890a.jpg]: https://gss3.bdstatic.com/-Po3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D41/sign=4c11c6f78c82b90139adc232718da7fe/e850352ac65c1038d0ae2312b4119313b17e890a.jpg