数据结构和算法分析：第二章 算法分析

算法是为求解一个问题所要遵循的，被清楚指定的简单指令的集合。

2.1 数学基础

相对增长率

大O标记法

2.2 模型

为了正式的架构中分析算法，我们需要一个计算模型。我们的模型基本上是一台标准的计算机，在机器中指令被顺序的执行。

2.3 要分析的问题

通常，要分析的最重要的资源就是运行时间。有几个因数影响着程序的运行时间。

因此只要有可能，使得算法足够有效而不成为问题的瓶颈是十分重要的。

2.4 运行时间计算

大O是一个上界

2.4.2 一般法则

1. 法则1—for循环：一个for循环的时间至多是该for循环内部那些语句的运行时间乘以迭代的次数。
2. 法则2—嵌套的for循环：从里向外分析这些for循环。在一组嵌套的循环内部的一条语句的总的运行时间为该语句的运行时间乘以该组所有的for循环的大小的乘积。
3. 法则3—顺序语句：将各个语句的运行时间求和即可。
4. 法则4—if、else语句：一个if/else的运行时间从不超过判断的运行时间加上S1和S2中运行时间长者的运行时间。

2.4.3 最大子序列求和问题的求解

时间复杂度O（N^3）

 public static int maxSubSum1(int nums[]){
        int maxSum=0;
        for(int i=0; i< nums.length; i++){
            for(int j=i; j<nums.length;j++){
                int thisSum=0;
                for(int tmp=i;tmp<=j;tmp++){
                    thisSum+=nums[tmp];
                }
                maxSum = maxSum > thisSum ? maxSum:thisSum;
            }
        }
        return maxSum;
    }

时间复杂度O（N^2）

    // 时间复杂度O（N^2）
    public static int maxSubSum2(int nums[]) {
        int maxSum = 0;
        for (int i = 0; i < nums.length; i++) {
            int thisSum = 0;
            for (int j = i; j < nums.length; j++) {
                thisSum += nums[j];
                maxSum = maxSum > thisSum ? maxSum : thisSum;
            }
        }
        return maxSum;
    }

2.4.4 运行时间的对数

分析算法最混乱的方面大概是集中在对数方面。此外对数最常出现的规律可概括为以下法则：如果一个算法用常数时间（O(1)）将问题的大小削减为其中一部分（通常为1/2），那么该算法就是O(㏒N)。另一方面，如果使用常数时间只是把问题减少为一个常数的数量（如将问题减少为1），那么这种算法就是O(N)。

• 折半查找

 // 折半查找
    public static <T extends Comparable<? super T>> int binarysearch(T[] a, T x){
        int low=0, high=a.length-1;

        while (low<=high){
            int mid=(low+high)/2;

            if(a[mid].compareTo(x)<0){
                low=mid+1;
            }else if(a[mid].compareTo(x)>0)
                high=mid-1;
            else
                return mid;
        }

        return -1;
    }

总结

时间复杂度

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

在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。

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

有时候，算法中基本操作重复执行的次数还随问题的输入数据集不同而不同，如在冒泡排序中，输入数据有序而无序，其结果是不一样的。此时，我们计算平均值。

常见的算法的时间 复杂度之间的关系为：

O(1)<O(logn)<O(n)<O(nlog n)<O(n2)<O(2n)<O(n!)<O(nn)

实例1

    sum=0；                	//（1）
    for(i=1;i<=n;i++)     	//（2）
    for(j=1;j<=n;j++)       //（3）
    sum++；             	//（4）

语句（1）执行1次，

语句（2）执行n次

语句（3）执行n2次

语句（4）执行n2次

T(n) = 1+n+2n2= O(n2)

实例2

    a=0; b=1;           //（1）
    for (i=1;i<=n;i++)   //（2）
    { 
       s=a+b;　　　　    //（3）
       b=a;　　　　　    //（4） 
       a=s;　　　　　    //（5）
    }

语句（1）执行1次，

语句（2）执行n次

语句（3）、（4）、（5）执行n次

T(n) = 1+4n =O(n)

**实例3**
```java
    i=1;            //（1）
    while (i<=n)
       i=i*2;       //（2）

语句（1）的频度是1,

设语句2的频度是f(n)，则：2f(n)<=n;f(n)<=log2n

取最大值f(n)= log2n,

T(n)=O(log2n )

空间复杂度

空间复杂度：算法所需存储空间的度量，记作：

  S(n)=O( f(n) )           

其中 n 为问题的规模。

一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。如果额外空间相对于输入数据量来说是个常数，则称此算法是原地工作。

算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。