算法的概述

第二章.算法

2.1算法定义

• 算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作
• 简而言之，算法就是解决问题的方法和步骤

2.2算法与程序

• 算法是解决问题的一种方法或一个过程，考虑如何将输入转换为输出，一个问题可以有多种算法
• 程序是某种程序设计语言对算法的具体实现
  • 程序=数据结构+算法
  • 数据结构通过算法实现操作
  • 算法根据数据结构设计程序

2.3算法的特性

• 输入输出
  • 一个算法有零个或多个的输入
  • 一个算法有一个或多个的输出
• 有穷性
  • 指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成
• 确定性
  • 算法的每一步骤都具有确定的含义，不会出现二义性
• 可行性
  • 算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成

2.4算法设计的要求

• 正确性
  • 算法的正确性是指算法至少应该具有输入、输出和加工处理无歧义性、能正确反映问题的需求、能够得到问题的正确答案
  • 算法转换为程序后需要注意
    • 程序中没有语法错误
    • 算法程序对于合法的输入数据能够产生满足要求的输出结果
    • 算法程序对于非法的输入数据能够得到满足规格说明的结果
    • 算法程序对于精心挑选的，甚至刁难的测试数据都有满足要求的输出结果
    • 通常我们会把第三条作为一个算法是否正确的标准
• 可读性
  • 算法设计的另一目的是为了便于阅读、理解和交流
  • 可读性高有助于人们理解算法，晦涩难懂的算法往往隐含错误，不易被发现，并且难于调试和修改
• 健壮性
  • 当输入数据不合法时，算法也能做出相关处理，而不是产生异常或莫名奇妙的结果
• 高效性
  • 要求花费尽量少的时间和尽量低的存储需求

2.5算法效率的度量

2.5.1时间效率和空间效率

• 时间效率：指的是算法所耗费的时间
• 空间效率：指的是算法执行过程中所耗费的存储空间
• 空间效率和时间效率有时候是矛盾的

2.5.2算法效率的度量方法

2.5.2.1事后统计方法

• 事后统计方法：这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低
• 缺陷
  • 必须依照算法事先编制好的程序，这通常需要花费大量的时间和精力
  • 时间的比较依赖计算机硬件和软件等环境因素，有时会掩盖算法本身的优劣
  • 算法的测试数据设计困难，并且程序的运行时间往往还与测试数据的规模有很大关系，效率高的算法在小的测试数据面前往往得不到体现

2.5.2.2事前分析估算方法

• 事前分析估算方法：在计算机程序编制前，依据统计方法对算法进行估算
• 一个程序在计算机上运行所耗时间因素
  • 算法采取的策略，方法
  • 编译产生的代码质量
  • 问题的输入规模
  • 机器执行指令的速度
• 一个程序的运行时间，依赖于算法的好坏和问题的输入规模。所谓问题输入规模是指输入量的多少
• 一个算法的运行时间是指一个算法在计算机上运行所耗费的时间大致可以等于计算机执行一种简单的操作（如赋值、比较、移动等）所需的时间与算法中进行的简单操作次数乘积
  • 算法运行时间=∑一个简单操作所需的时间*简单操作次数
  • 每条语句执行一次所需的时间，一般是随机器而异的。取决于机器的指令性能、速度以及编译的代码质量。是由机器本身硬件环境决定的，它与算法无关
  • 所以，我们可以假设执行每条语句所需的时间均为单位时间。此时对算法的运行时间的讨论可转换为讨论该算法中所有语句的执行次数，即频度之和了。

public static int sum(int[] array) {
    int result = 0;						              //1次				
    for (int i = 0; i < array.length; i++) {          //数组长度，假设为n    n次
        result += array[i];							  //2n次  数组索引访问操作、赋值操作
    }  
    return result;                                    //1次                      
}

上述算法的时间消耗T(n)=2n+n+2

2.6算法时间复杂度

2.6.1算法时间复杂度定义

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

2.6.2推导大O阶方法

1. 计算基本操作次数：首先要确定算法中进行的基本操作是什么，然后计算这些操作在算法中出现的次数
2. 确定最高项和系数：将基本操作次数表示为一个多项式，然后确定最高项及其系数。例如，如果基本操作次数表示为3n^{2+2n+1,则最高项为n}2，系数为3
3. 忽略低次项和常数项：由于在算法的输入规模趋近于无穷大时，低次项和常数项对复杂度的影响较小，因此可以忽略这些项
4. 确定时间复杂度：将最高项作为算法的时间复杂度，例如，3n^2 + 2n + 1的时间复杂度为O(n^2)

2.6.3常见的时间复杂度

常见的时间复杂度所耗费的时间从大到小排列如下：
O(1) < O(log n) < O(n) < O(n log n) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

2.6.3.1常数阶（O(1)）

public static int sum(int a, int b) {
    return a + b;					//1次
}

这个算法的基本操作只有一次整数加法操作，不论输入参数的大小，
时间消耗总数都是常数级别的

2.3.3.2线性阶（O(n)）

public static int sum(int[] array) {
    int result = 0;								//1次
    for (int i = 0; i < array.length; i++) {	//length次
        result += array[i];						//2length次
    }
    return result;
}

这个算法的基本操作是每次循环迭代中的一次索引访问操作和一次加法操作，
时间消耗总数与数组长度成线性关系

2.3.3.3平方阶（O(n^2)）

public static void printPairs(int[] array) {
    for (int i = 0; i < array.length; i++) {   
        for (int j = 0; j < array.length; j++) {  
            System.out.println("(" + array[i] + ", " + array[j] + ")");
        }
    }
}

这个算法的基本操作是每次内层循环迭代中的一次索引访问操作和一次输出操作，
时间消耗总数与数组长度的平方成正比

2.3.3.4对数阶（O(logn)）

public static int sum(int n) {
    int result = 1;								
    while(result<n)
	{
        result=result*2
	}
    return result;
}

由于每次result乘以2之后，就距离n更进一步。也就是说，有多少个2相乘后会大于n，
则退出循环。由2的x次方即可得到时间复杂度为O(logn)

2.6.4最坏情况与平均情况

• 最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。在应用中，这是一种最重要的需求。通常，除非特别指定，我们提到的运行时间都是最坏情况的运行时间
• 平均运行时间，指在所有可能输入实例在等概率出现的情况下，算法的期望时间

2.7算法空间复杂度

• 算法的空间复杂度通过计算算法所需要的存储空间实现，算法空间复杂度的计算公式记作：S(n)=O(f(n))，其中n为问题的规模，f(n)为语句关于n所占存储空间的函数

public static int fibonacci(int n) {
    if (n == 0 || n == 1) {
        return n;
    }
    int prev1 = 0, prev2 = 1;
    int result = 0;
    for (int i = 2; i <= n; i++) {
        result = prev1 + prev2;
        prev1 = prev2;
        prev2 = result;
    }
    return result;
}

斐波那契数列是一个由0和1开始的数列，后面的每一项都是前面两项的和
在上述代码中，我们使用循环的方式来计算斐波那契数列第n项的值。
首先判断n是否为0或1，如果是直接返回n；否则通过循环计算f(2)到f(n)的值，
其中prev1和prev2分别表示f(i-2)和f(i-1)的值，result表示f(i)的值。
由于循环计算不需要使用递归，因此空间复杂度为O(1)