1  算法概念

     软件 的 最终 成果 都是 以 程序 的 形式 表现 的， 数据 结构 的 各种 操作 都是 以 算法 的 形式 描述 的。 数据 结构、 算法 和 程序 是 密不可分 的。 三 者 的 关系 正如 瑞士 苏黎世 联邦 工业 大学 著名 计算机 科学家 沃 思（ Wirth） 提出 的 一个 公式： 数据 结构+ 算法= 程序。 其中， 算法 是 灵魂， 它 解决“ 做 什么” 和“ 怎么 做” 的 问题。 在给 出 算法 的 概念 之前， 先 举 两个 例子 来说 明 什么 是 算法。

 例1 　 求 1+ 2+ 3+ 4+…+ 100=？

 方法 1： 直接 相加， 得出 结果。 

方法 2：= 100+（ 1+ 99）+（ 2+ 98）+…+（ 49+ 51）+ 50 　 　 　= 50* 100+ 50 　 　 　= 5050 

例2 　 求 1* 2* 3* 4* 5=？ 

最 原始 的 方法： S1： 先 求 1* 2， 得 2。 　 　 　 　 

S2： 将 2* 3， 得 6。

S3： 将 6* 4， 得 24。 　 　 　 

S4： 将 24* 5= 120， 便得 到 最后 的 结果。

若 求 1* 2* 3*…* 1000=？， 再用 此 方法 就不 可行。 因为 需要 999 个 步骤， 故要 找 一种 通用 的 方法。 可设 两个 变量， 一个 变量 代表 被乘数（ p）， 一个 变量 代表 乘数（ i）。 S1： 使 p= 1。 S2： 使 i= 2。 S3： 使 p* i， 将 p* i= ＞ p。 S4： i+ 1= ＞ i。 S5： 若 i 不大于 5， 返回 重新 执行 S3、 S4 和 S5； 否则， 算法 结束。 

可见， 算法（ Algorithm） 是对 特定 问题 求解 步骤 的 一种 描述， 是 指令 的 有限 序列。 其中 每 一条 指令 表示 一个 或 多个 操作。

2  算法的特征

算法 的 特征

一个 算法 应该 具有 下列 特性。

 ① 有 穷 性： 一个 算法 应 包含 有限 的 操作步骤， 而 不能 是 无限 的。 

② 确定性： 每一 步 应是 确定 的， 而 不应 是 含糊 的、 模棱两可 的， 即 无 二义性。

 ③ 有 输入： 有零 个 或 多个 输入。

 ④ 有 输出： 有一个 或 多个 输出， 算法 的 目的 是 为了“ 解”， 求 结果。 所以， 没有 输出 的 算法 是 没有 意义 的。

 ⑤ 有效性（ 可行性）。 算法 中的 每一 步 都应 能 有效地 执行， 并 得到 确定 的 结果， 如 b= 0， 则 表达式 a/ b 是 不能 有效 执行 的。

3  算法 分析

          我们常常说时间复杂度，空间复杂度，但是涉及到具体的算法分析的时候不知道怎么去计算复杂点的时间复杂度，下面为大家理清一下，参考《数据结构》一书

             衡量 算法 优劣 最重要的 一点 是 效率 与 低 存储 量 要求。 算法 效率（ 算法 运行 的 时间） 由 时间 复杂度 来 度量。 一般， 鉴于 空间（ 内存） 较为 充足， 故 把 算法 的 时间 复杂度 作为 分析 的 重点。 在 求 时间 复杂度 之前， 先 介绍 频度 统计法。

             频度： 一条 语句 的 频度 是指 该 语句 被 执行 的 次数。 而 整个 算法 的 频度 是指 算法 中 所有 基本 语句 的 频度 之和。

例如：求下面的语句频度

分析： 该 算法 为 一个 二重 循环， 执行 次数 为 内、 外 循环 次数 相乘， 因此 频度= n²（2是指数，不知道怎么打出来，后面如果2在后面的话都表示指数）。

3.1  时间 复杂度

        在 刚才 提到 的 算法 频度 中， n 称为 问题 的 规模（ 通常用 正 整数 n 表示）。 当 n 不断 变化 时， 语句 频度 也会 不断 变化。 但 有时 我们 想知道 它 变化 时 呈现 什么 规律。 为此， 我们 引入 时间 复杂度 概念。 或者说 时间 复杂度 是 问题 规模 的 函数。 但 算法 的 时间 复杂度 考虑 的 只是 对 问题 规模 n 的 增长率， 难以 精确 计算 出 语句 频度， 只需 求出 它 关于 n 的 增长率 或 阶（ 数量级） 即可。

        一般 情况下， 算法 中 基本 操作 重复 执行 的 次数 是 问题 规模 n 的 某个 函数 f（ n）， 记作 T（ n）= O（ f（ n））。

其中， T（ n） 表示 时间 复杂度， 大写字母 O 为 英文 Order（ 即 数量级） 单词 的 第一个 字母。

例如，

语句 x= x+ 1 执行 次数 关于 n 的 增长率 为 n²， 故 它的 时间 复杂度 T（ n）= O（ n²）。

可能这个比较简单，下面看看复杂点的时间复杂度

求出 下列 算法 段 的 时间 复杂度。

分析可知：（1）    T（ n）= O（1） 常数级

(2)   T(n) = O(n)

第三段代码（3）  ①的频度是n-1(因为k<n,没有等于)      ②的频度是T（n） = （n-1）* (2n +1) = 2n2- n- 1   则 该 程序 段 的 时间 复杂度 T（ n）= n- 1+ 2n²- n- 1= O（ n²）。

第 4 段 代码 是 三层 for 循环， 故 时间 复杂度 为 O（ n3）。

第 5 段 代码 中的 语句 ① 的 频度 是 1， 语句 ② 的 频度 设为 f（ n）， 则有 2 f（ n） ≤ n， 即 f（ n） ≤ log2n， 取 最大值 f（ n）= log2n。 故 该 程序 段 的 时间 复杂度 T（ n）= 1+ log2n= O（ log2n）。很多人可能不理解2 f（ n） ≤ n是怎么得来的，大家可以把n设置为10，带入去计算一下，你会发现 2 f（ n） ≤ n  总会成立。

总结： 在各 种 不同 算法 中， 若 程序 的 运行 时间 不随 着 问题 规模 n 的 增加 而 增长， 即使 算法 中有 上千 条 语句， 其 执行 时间 也不 过 是一 个 较大 的 常数， 此类 算法 的 时间 复杂度 仍是 O（ 1）。 另外， 在 频度 不相 同时， 时间 复杂度 有可能 相同， 如 T（ n）= n2+ 3n+ 4 与 T（ n）= 4n2+ 2n+ 1 的 频度 不同， 但 时间 复杂度 相同， 都为 O（ n2）。 按 数量级 递增 排列， 常见 的 时间 复杂度 有 常数 阶 O（ 1）、 对数 阶 O（ log2n）、 线性 阶 O（ n）、 线性 对数 阶 O（ nlog2n）、 平方 阶 O（ n2）、 立方 阶 O（ n3）… k 次方 阶 O（ nk）、 指数 阶 O（ 2n）。 随着 问题 规模 n 的 不断 增大， 上述 时间 复杂度 不断 增大， 算法 的 执行 效率 降低。

3.2 空间复杂度

            一个 程序 需要 的 空间 即 存储 量， 包括 输入 数据 所占 空间、 程序 本身 所占 空间 和 辅助 变量 所占 空间。 我们 一般 是 讨论 算法 占用 的 辅助 存储 空间， 即 空间 复杂度 是对 一个 算法 在 运行 过程中 临时 占用 的 存储 空间 大小 的 量度。 一般 也作 为 问题 规模 n 的 函数， 以 数量级 形式 给出， 记作： S（ n）= O（ g（ n））