算法效率的度量方法（第二天）

算法效率的度量方法

本章内容可分为：

1. 如何来度量一个算法的执行时间呢？
2. 算法的时间复杂度
3. 算法的空间复杂度

上章中，我们提到设计算法要尽量的提高效率，这里效率高一般指的是算法的执行时间。

如何来度量一个算法的执行时间呢？

所谓“是骡子是马拉出来遛遛”，比较容易想到的方法就是我们把算法跑若干次，然后拿个“计时器”在旁边计时。这种方法便为：事后统计方法。
事后统计方法：这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低。但是这种方法有很大的缺陷：

1. 必须依据算法事先编制好的测试程序，通常需要花费大量时间和精力。
2. 不用测试环境差别不是一般的大

为了对算法的评判更为科学和便捷，出现了“事前分析估算”的方法。
事前分析估算方法：在计算机程序编写前，依据统计方法对算法进行估算。
经总结，我们发现一个高级语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：

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

由此可见，抛开这些与计算机及硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。（所谓的问题输入规模是指输入量的多少）
例如：上章中的1+2+3+…+100的求和问题。

//第一种算法：
int i, sum = 0 , n = 100 ; //执行1次
for(i=1 ; i <= n; i++){
         //执行了n+1次
 sum += i;   //执行n次
 }

//第二种算法：
int sun = 0 , n = 100;  //执行1次
sum = (1+n)*n/2;        //执行1次

第一种算法执行了1+(n+1)+n = 2n+2次。第二种算法执行了1+1 = 2次。
如果我们将循环看作一个整体，忽略头尾判断的语句，那么这两个算法其实就是n和1的差距。因为循环判断在算法1里面执行力n+1次，当n的值越大，循环的次数越多，消耗的时间就越长，而如果算法执行一次，那么不论 n 值有多大，算法只执行一次，与 n 值无关。

再举个例子：

int i, j, x=0, sum=0, n=100;
for( i=1; i <= n; i++){
 for( j = 1; j<=n;j++){
  x++;
  sum = sum + x;
 }
}

在这个例子中，循环条件 i 从 1 到 100 ，每次都要让j循环 100 次，总共循环 100^2 (即100*100） 次，由此可见，当数值较大时，我们不易使用循环来进行算法处理。
我们研究算法的复杂度，侧重的是研究算法随着输入规模扩大增长量的一个抽象，而不是精确的定位需要执行多少次。我们在分析算法的运行时间时，重要的是把基本操作的数量和输入模式关联起来。
在这里我们将引入“函数的渐进增长”对算法执行的效率进行判断。
函数的渐进增长：给定两个函数 f(n) 和 g(n) ，如果存在一个整数 N ，使得对于所有的 n > N ，f(n) 总是比 g(n) 大， 那么， 我们说 f(n) 的增长渐近快于 g(n) 。
我们常常在判断一个算法的效率时，函数中的常数和其他次要项常常可以忽略，而更应该关注主项（最高项）的阶数。
注意：判断一个算法好不好，我们只通过少量的数据是不可以做出准确判断的，很容易以偏概全。

算法时间复杂度

何为算法时间复杂度？

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

计算算法时间复杂度的技巧

如何分析一个算法的时间复杂度呢？

• 用常数1取代运行时间中的所有加法常数
• 在修改后的运行次数函数中，只保留最高阶项
• 如果最高阶项存在且不是1，则去除与这个项相乘的常数。
• 得到的最后结果就是算法的时间复杂度

下面为大家介绍几个实例，作为练习：
1、常数阶

//常数阶
int sum = 0, n = 100;
printf("I love study!\n");
printf("I love study!\n");
printf("I love study!\n");
sum = (1+n)*n/2;

大家觉得这段代码的时间复杂度为多少呢？

1. 首先，我们看过时间复杂度的定义知道“ T(n) 是关于问题规模 n 的函数”，那么，我们只用看关于 n 的语句就可以了
2. 在上述代码中，只有sum = (1+n)*n/2;是关于 n 的语句，由于他只运行了一次，所以这段代码的时间复杂度为 O(1)。

2、线性阶
一般含有非嵌套循环涉及线性阶，线性阶就是随着问题规模 n 的扩大，对应计算次数呈直线增长。

int i , n = 100, sum = 0;
for( i=0 ; i

上面这段代码，它的循环的时间复杂度为O(n)，因为循环体中的代码需要执行 n 次。

3、平方阶

int i, j, n = 100;
for( i = 0; i < n; i++ ){
     
 for( j=0 ; j < n; j++ ){
     
  printf("I love study!");
 }
}

这段代码中 n 等于100，也就是说外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环出来，需要执行100*100次，也就是 n 的平方。所以这段代码的时间复杂度为O(n^2)。

int i, j, n = 100;
for( i = 0; i < n; i++ ){
     
 for( j=i ; j < n; j++ ){
     
  printf("I love study!");
 }
}

这段代码就和上面的代码有所不同了，这样的该如何求解呢？
分析一下，由于当 i =0 时，内循环执行了 n 次，当 i = 1 时，内循环则执行 n - 1次 . . . . . . . 当 i = n -1 时，内循环执行 1 次，所以总的执行次数应该是：n+(n-1)+(n-2)+…+1=n(n+1)/2
继续推算：n(n+1)/2 = n^2/2+n/2。
按照我们上述的计算方法，第一条忽略，因为没有常数相加。第二条只保留最高项，所以n/2这项去掉。第三条，去除与最高项相乘的常数，最终得O(n^2)。

4、对数阶

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

由于每次 i*2 之后，就距离 n 更近一步，假设有 X 个2相乘后大于或等于 n，则会退出循环。于是由 2^X = n 得到 X = log(2)n,所以这个循环的时间复杂度为O(logn)。

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

上面讲述的代码内容，其实很容易，我们现在把问题实际化一点，大家看看是否可以正确的分析出来。

int i, j;
for( i =0; i < n; i++ ){
     
 function(i);
}
void function(int count){
     
 printf("%d" , count)
}

函数体是打印这个参数，这很好理解。function函数的时间复杂度是O(1)，所以整体的时间复杂度就是循环的次数O(n)。

假如function是下面这样，又该如何呢？

void function(int count){
     
 int j;
 for( j =count; j < n; j++){
     
  printf("%d", j);
 }
}

事实上，这和上面的平方阶是一样的，function内部的循环次数随count的增加（接近n）而减少，所以根据上面的推理步骤，该代码的算法时间复杂度为O(n^2)。

上面的例子也许太过于简单了，下面我将为大家准备一个复杂的例子：

n++;   //执行了 1 次
function(n);  //执行了 n^2 次
for( i =0; i<n ; i++){
         //执行了 n^2 次 
 function(i);
}
for( i=0; i < n; i++){
        //执行了 n^2 次
 for(j = i ; j < n ; j++){
     
  printf("%d",j);
 }
}
void function(int count){
     
 int j;
 for( j =count; j < n; j++){
     
  printf("%d", j);
 }
}

相加得：3*(n^2) + 1,出去常数，保留最高阶，即得该算法的时间复杂度为O( n ^ 2)。
常见的时间复杂度

例子	时间复杂度
999666	O(1)
3n + 4	O(n)
3n^2+4n+5	O(n^2)
3log(2)n+4	O(logn)
2n+3nlog(2)n+14	O(nlogn)
n^3 + 2 n ^2+4n+6	O(n^3)
2^n	O(2^n)

常用的时间复杂度所耗费的时间从小到大依次是：O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O( n ^3) < O(2 ^n) < O(n!) < O(n ^n)。

算法的空间复杂度

我们在写代码时，完全可以用空间来换取时间。

何为算法的空间复杂度

算法的空间复杂度通过计算算法所需的存储空间实现，算法的空间复杂度的计算公式记作：S(n) = O(f(n))，其中，n 为问题的规模，f(n)为语句关于 n 所占存储空间的函数。
通常来说，用“时间复杂度”来指运行时间的需求，用“空渐渐复杂度”来指空间需求。当直接要求我们求“复杂度”的时候，通常是指是时间复杂度。

下章 Tip

我们下章的笔记将会是：数据结构——线性表。