原文地址：http://www.cnblogs.com/gaochundong/p/complexity_of_algorithms.html
为什么要对算法进行分析呢？
- 预测算法所需的资源
- 计算时间（CPU 消耗）
- 内存空间（RAM 消耗）
- 通信时间（带宽消耗）
- 预测算法的运行时间
- 计算指令执行的数量，或者称为算法复杂度（Algorithm Complexity）
如何衡量算法复杂度呢？
- 内存（Memory）
- 时间（Time）
- 指令的数量（Number of Steps）
- 特定操作的数量
- 磁盘访问数量
- 网络包数量
- 渐进复杂度（Asymptotic Complexity）
算法复杂度所包含的情况：
- 最坏情况（Worst Case）
- 平均情况（Average Case）
- 最佳情况（Best Case）
例如，在一个长度为 n 的列表中顺序搜索指定的值，则
- 最坏情况：n 次比较
- 平均情况：n/2 次比较
- 最佳情况：1 次比较
而实际中，我们一般仅考量算法在最坏情况下的运行情况，也就是对于规模为 n 的任何输入，算法的最长运行时间。这样做的理由是：
- 一个算法的最坏情况运行时间是在任何输入下运行时间的一个上界（Upper Bound）。
- 对于某些算法，最坏情况出现的较为频繁。
- 大体上看，平均情况通常与最坏情况一样差。
算法复杂度通常使用 O 记号法（Big O Notation）来表示最坏运行情况的上界。例如，
- 线性复杂度 O(n) 表示每个元素都要被处理一次。
- 平方复杂度 O(n2) 表示每个元素都要被处理 n 次。
注：快速的数学回忆，logab = y 其实就是 ay = b。所以，log24 = 2，因为 22 = 4。同样 log28 = 3，因为 23 = 8。我们说，log2n 的增长速度要慢于 n，因为当 n = 8 时，log2n = 3。
而通常时间复杂度与运行时间有一些常见的比例关系：
计算代码块的渐进运行时间的方法有如下步骤：
- 确定决定算法运行时间的组成步骤。
- 找到执行该步骤的代码，标记为 1。
- 查看标记为 1 的代码的下一行代码。如果下一行代码是一个循环，则将标记 1 修改为 1 倍于循环的次数 1 * n。如果包含多个嵌套的循环，则将继续计算倍数，例如 1 * n * m。
- 找到标记到的最大的值，就是运行时间的最大值，即算法复杂度描述的上界。
示例代码（1）：
1 decimal Factorial(int n)
2 {
3 if (n == 0)
4 return 1;
5 else
6 return n * Factorial(n - 1);
7 }
阶乘（factorial），给定规模 n，算法基本步骤执行的数量为 n，所以算法复杂度为 O(n)。
示例代码（2）：
1 int FindMaxElement(int[] array)
2 {
3 int max = array[0];
4 for (int i = 0; i < array.Length; i++)
5 {
6 if (array[i] > max)
7 {
8 max = array[i];
9 }
10 }
11 return max;
12 }
这里，n 为数组 array 的大小，则最坏情况下需要比较 n 次以得到最大值，所以算法复杂度为 O(n)。
示例代码（3）：
1 long FindInversions(int[] array)
2 {
3 long inversions = 0;
4 for (int i = 0; i < array.Length; i++)
5 for (int j = i + 1; j < array.Length; j++)
6 if (array[i] > array[j])
7 inversions++;
8 return inversions;
9 }
这里，n 为数组 array 的大小，则基本步骤的执行数量约为 n*(n-1)/2，所以算法复杂度为 O(n2)。
示例代码（4）：
1 long SumMN(int n, int m)
2 {
3 long sum = 0;
4 for (int x = 0; x < n; x++)
5 for (int y = 0; y < m; y++)
6 sum += x * y;
7 return sum;
8 }
给定规模 n 和 m，则基本步骤的执行数量为 n*m，所以算法复杂度为 O(n2)。
示例代码（5）：
1 decimal Sum3(int n)
2 {
3 decimal sum = 0;
4 for (int a = 0; a < n; a++)
5 for (int b = 0; b < n; b++)
6 for (int c = 0; c < n; c++)
7 sum += a * b * c;
8 return sum;
9 }
这里，给定规模 n，则基本步骤的执行数量约为 n*n*n ，所以算法复杂度为 O(n3)。
示例代码（6）：
1 decimal Calculation(int n)
2 {
3 decimal result = 0;
4 for (int i = 0; i < (1 << n); i++)
5 result += i;
6 return result;
7 }
这里，给定规模 n，则基本步骤的执行数量为 2n，所以算法复杂度为 O(2n)。
示例代码（7）：
斐波那契数列：
- Fib(0) = 0
- Fib(1) = 1
- Fib(n) = Fib(n-1) + Fib(n-2)
F() = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ...
1 int Fibonacci(int n)
2 {
3 if (n <= 1)
4 return n;
5 else
6 return Fibonacci(n - 1) + Fibonacci(n - 2);
7 }
这里，给定规模 n，计算 Fib(n) 所需的时间为计算 Fib(n-1) 的时间和计算 Fib(n-2) 的时间的和。
T(n<=1) = O(1)
T(n) = T(n-1) + T(n-2) + O(1)
fib(5)
/
fib(4) fib(3)
/ /
fib(3) fib(2) fib(2) fib(1)
/ / /
通过使用递归树的结构描述可知算法复杂度为 O(2n)。
示例代码（8）：
1 int Fibonacci(int n)
2 {
3 if (n <= 1)
4 return n;
5 else
6 {
7 int[] f = new int[n + 1];
8 f[0] = 0;
9 f[1] = 1;
10
11 for (int i = 2; i <= n; i++)
12 {
13 f[i] = f[i - 1] + f[i - 2];
14 }
15
16 return f[n];
17 }
18 }
同样是斐波那契数列，我们使用数组 f 来存储计算结果，这样算法复杂度优化为 O(n)。
示例代码（9）：
1 int Fibonacci(int n)
2 {
3 if (n <= 1)
4 return n;
5 else
6 {
7 int iter1 = 0;
8 int iter2 = 1;
9 int f = 0;
10
11 for (int i = 2; i <= n; i++)
12 {
13 f = iter1 + iter2;
14 iter1 = iter2;
15 iter2 = f;
16 }
17
18 return f;
19 }
20 }
同样是斐波那契数列，由于实际只有前两个计算结果有用，我们可以使用中间变量来存储，这样就不用创建数组以节省空间。同样算法复杂度优化为 O(n)。
示例代码（10）：
通过使用矩阵乘方的算法来优化斐波那契数列算法。
1 static int Fibonacci(int n)
2 {
3 if (n <= 1)
4 return n;
5
6 int[,] f = { { 1, 1 }, { 1, 0 } };
7 Power(f, n - 1);
8
9 return f[0, 0];
10 }
11
12 static void Power(int[,] f, int n)
13 {
14 if (n <= 1)
15 return;
16
17 int[,] m = { { 1, 1 }, { 1, 0 } };
18
19 Power(f, n / 2);
20 Multiply(f, f);
21
22 if (n % 2 != 0)
23 Multiply(f, m);
24 }
25
26 static void Multiply(int[,] f, int[,] m)
27 {
28 int x = f[0, 0] * m[0, 0] + f[0, 1] * m[1, 0];
29 int y = f[0, 0] * m[0, 1] + f[0, 1] * m[1, 1];
30 int z = f[1, 0] * m[0, 0] + f[1, 1] * m[1, 0];
31 int w = f[1, 0] * m[0, 1] + f[1, 1] * m[1, 1];
32
33 f[0, 0] = x;
34 f[0, 1] = y;
35 f[1, 0] = z;
36 f[1, 1] = w;
37 }
优化之后算法复杂度为 O(logn)。
示例代码（11）：
在 C# 中更简洁的代码如下。
1 static double Fibonacci(int n)
2 {
3 double sqrt5 = Math.Sqrt(5);
4 double phi = (1 + sqrt5) / 2.0;
5 double fn = (Math.Pow(phi, n) - Math.Pow(1 - phi, n)) / sqrt5;
6 return fn;
7 }
本篇文章《算法复杂度分析》由 Dennis Gao 发表自博客园，任何未经作者同意的爬虫或人为转载均为耍流氓。