算法--02---时间空间复杂度

Posted 2021-08-08 高高for 循环

算法分析

概念：

• 前面我们已经介绍了，研究算法的最终目的就是如何花更少的时间，如何占用更少的内存去完成相同的需求
• 有关算法时间耗费分析，我们称之为算法的时间复杂度分析
• 有关算法的空间耗费分析，我们称之为算法的空间复杂度分析。

估算方法：

• 事后分析估算方法：
• 事前分析估算方法：

事后分析估算方法：

比较容易想到的方法就是我们把算法执行若干次，然后拿个计时器在旁边计时，这种事后统计的方法看上去的确不错，并且也并非要我们真的拿个计算器在旁边计算，因为计算机都提供了计时的功能。这种统计方法主要是通过设计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率的高低，

但是这种方法有很大的缺陷：

1. 必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了。
2. 并且不同的测试环境(硬件环境)的差别导致测试的结果差异也很大。
   

事前分析估算方法：

在计算机程序编写前，依据统计方法对算法进行估算，经过总结，我们发现一个高级语言编写的程序程序在计算机上运行所消耗的时间取决于下列因素：

1. 算法采用的策略和方案；
2. 编译产生的代码质量；
3. 问题的输入规模(所谓的问题输入规模就是输入量的多少)；
4. 机器执行指令的速度；

由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了。

算法估算原则：

在研究算法的效率时，我们只考虑核心代码的执行次数，这样可以简化分析

我们研究算法复杂度，侧重的是当输入规模不断增大时，算法的增长量的一个抽象(规律)，而不是精确地定位需要执行多少次。

我们分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来。

• 我们不关心编写程序所用的语言是什么，也不关心这些程序将跑在什么样的计算机上，我们只关心它所实现的算法。
• 这样，不计那些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，
• 最终在分析程序的运行时间时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。我们分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来。

常数时间操作

函数渐近增长

概念：

• 给定两个函数f(n)和g(n),如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么我们说f(n)的增长渐近快于g(n)。

测试一：

随着输入规模的增大，算法的常数操作可以忽略不计

测试二：

随着输入规模的增大，与最高次项相乘的常数可以忽略

测试三：

最高次项的指数大的，随着n的增长，结果也会变得增长特别快

测试四：

算法函数中n最高次幂越小，算法效率越高

小结：

1. 算法函数中的常数可以忽略；
2. 算法函数中最高次幂的常数因子可以忽略；
3. 算法函数中最高次幂越小，算法效率越高。

算法时间复杂度 —大O记法

定义：

• 在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n)的量级。
• 算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。
• 它表示随着问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。

在这里，我们需要明确一个事情：执行次数=执行时间

• 用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法。

大O表示法—案例：

算法一：

算法二：

算法三：

如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为：

• 算法一：3次
• 算法二：n+3次
• 算法三：n^2+2次

所以，上述算法的大O记法分别为：

• 算法一：O(1)
• 算法二：O(n)
• 算法三：O(n^2)

大O阶的表示法规则

基于我们对函数渐近增长的分析，推导大O阶的表示法有以下几个规则可以使用：

1. 用常数1取代运行时间中的所有加法常数；
2. 在修改后的运行次数中，只保留高阶项；
3. 如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数；

常见的大O阶：

1. 线性阶
2. 平方阶
3. 立方阶
4. 对数阶
5. 常数阶
   
   
   
   
   
   
   

常见时间复杂度的一个小结：

他们的复杂程度从低到高依次为：

O(1)<O(logn)<O(n)<O(nlogn)<O(n^2) <O(n^3)

• 根据前面的折线图分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，我们的算法，尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，
• 而如果发现算法的时间复杂度为平方阶、立方阶或者更复杂的，那我们可以分为这种算法是不可取的，需要优化。

函数调用的时间复杂度分析

案例一：

 public static void main(String[] args) {
        int n=100;
        for (int i = 0; i < n; i++) {
            show(i);
        }
    }
    private static void show(int i) {
        System.out.println(i);
    }

• 在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)

时间复杂度就是O(n)

案例二：

public static void main(String[] args) {
        int n=10;
        for (int i = 0; i < n; i++) {
            show(i);
        }
    }
    private static void show(int i) {
        for (int j = 0; j < i; j++) {
            System.out.println(j);
        }
    }

分析:

1. show方法总共执行10次
2. 每次调用show方法时,会输出(i-1)次System.out.println() 方法
3. 所以当总共为 n=10时 ,f(10)=10+1+2+3+4+5+6+7+8+9=55

测试方法1

• 程序中加入k来计数

public class Test01 {

    public static void main(String[] args) {
        int k=0;

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

        System.out.println();
        System.out.println("总次数: "+k);

    }

    private static int show(int i,int K) {
        for (int j = 0; j < i; j++) {
            System.out.print(i+"-");
            K++;
        }
        return K;
    }
}

测试方法2

• 数学推导
  
  当n=10时,结果为50+5=55

在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法的时间复杂度为O(n),那main方法的时间复杂度为O(n^2)

时间复杂度为O(n^2)

案例三：

1. 在main方法中，show(n)这行代码内部执行的次数为n，
2. 第一个for循环内调用了show方法，所以其执行次数近似为n^2,
3. 第二个嵌套for循环内只执行了一行代码，所以其执行次数为n^2,
   

根据大O推导规则，去掉n保留最高阶项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为O(n^2)

时间复杂度为O(n^2)

最坏情况:

从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说：哇哦，还有半杯水哦！但也有人会说：天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快乐。

算法分析也是类似，假如有一个需求：

• 有一个存储了n个随机数字的数组，请从中查找出指定的数字。
  

• 最好情况：
  查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)

• 最坏情况：
  查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)

• 平均情况：
  任何数字查找的平均成本是O(n/2)

最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以，除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间。

算法的空间复杂度

背景:

• 计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k,经历了1M，2M，4M…等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也是一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。

java中常见内存占用:

1.基本数据类型

2.计算机访问内存的方式都是一次一个字节

3.一个引用（机器地址）需要8个字节表示：

例如： Date date = new Date(),则date这个变量需要占用8个字节来表示

4.创建一个对象

1. 创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，
2. 该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。

5.一般内存的使用，如果不够8个字节，都会被自动填充为8字节：

6.java中数组

• java中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)
• 再加上保存值所需的内存。

算法的空间复杂度:

• 了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。
• 算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。

案例:

需求:

• 对指定的数组元素进行反转，并返回反转的内容

解法一：

解法二：

忽略判断条件占用的内存，我们得出的内存占用情况如下：

算法一：

• 不管传入的数组大小为多少，始终额外申请4+4=8个字节；
• 空间复杂度为O(1),

算法二：

• 4+4n+24=4n+28;
• 空间复杂度为O(n)

根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为O(n),所以从空间占用的角度讲，算法一要优于算法二。

小结:

• 由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。

• 由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。

• 如果你做的程序是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。