算法复杂度分析

原文地址：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 的任何输入，算法的最长运行时间。这样做的理由是：

1. 一个算法的最坏情况运行时间是在任何输入下运行时间的一个上界（Upper Bound）。
2. 对于某些算法，最坏情况出现的较为频繁。
3. 大体上看，平均情况通常与最坏情况一样差。

算法复杂度通常使用 O 记号法（Big O Notation）来表示最坏运行情况的上界。例如，

• 线性复杂度 O(n) 表示每个元素都要被处理一次。
• 平方复杂度 O(n²) 表示每个元素都要被处理 n 次。

复杂度	标记符号	描述
常量（Constant）	O(1)	操作的数量为常数，与输入的数据的规模无关。 n = 1,000,000 -> 1-2 operations
对数（Logarithmic）	O(log n)	操作的数量与输入数据的规模 n 的比例是 log2 (n)。 n = 1,000,000 -> 30 operations
线性（Linear）	O(n)	操作的数量与输入数据的规模 n 成正比。 n = 10,000 -> 5000 operations
平方（Quadratic）	O(n2)	操作的数量与输入数据的规模 n 的比例为二次平方。 n = 500 -> 250,000 operations
立方（Cubic）	O(n3)	操作的数量与输入数据的规模 n 的比例为三次方。 n = 200 -> 8,000,000 operations
指数（Exponential）	O(2n)  O(kn)  O(n!)	指数级的操作，快速的增长。 n = 20 -> 1048576 operations

注：快速的数学回忆，log_ab = y 其实就是 a^y = b。所以，log₂4 = 2，因为 2² = 4。同样 log₂8 = 3，因为 2³ = 8。我们说，log₂n 的增长速度要慢于 n，因为当 n = 8 时，log₂n = 3。

而通常时间复杂度与运行时间有一些常见的比例关系：

复杂度	10	20	50	100	1000	10000	100000
O(1)	<1s	<1s	<1s	<1s	<1s	<1s	<1s
O(log(n))	<1s	<1s	<1s	<1s	<1s	<1s	<1s
O(n)	<1s	<1s	<1s	<1s	<1s	<1s	<1s
O(n*log(n))	<1s	<1s	<1s	<1s	<1s	<1s	<1s
O(n2)	<1s	<1s	<1s	<1s	<1s	2s	3-4 min
O(n3)	<1s	<1s	<1s	<1s	20s	5 hours	231 days
O(2n)	<1s	<1s	260 days	hangs	hangs	hangs	hangs
O(n!)	<1s	hangs	hangs	hangs	hangs	hangs	hangs
O(nn)	3-4 min	hangs	hangs	hangs	hangs	hangs	hangs

计算代码块的渐进运行时间的方法有如下步骤：

1. 确定决定算法运行时间的组成步骤。
2. 找到执行该步骤的代码，标记为 1。
3. 查看标记为 1 的代码的下一行代码。如果下一行代码是一个循环，则将标记 1 修改为 1 倍于循环的次数 1 * n。如果包含多个嵌套的循环，则将继续计算倍数，例如 1 * n * m。
4. 找到标记到的最大的值，就是运行时间的最大值，即算法复杂度描述的上界。

示例代码（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(n²)。

示例代码（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(n²)。

示例代码（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(n³)。

示例代码（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，则基本步骤的执行数量为 2ⁿ，所以算法复杂度为 O(2ⁿ)。

示例代码（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(2ⁿ)。

示例代码（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 发表自博客园，任何未经作者同意的爬虫或人为转载均为耍流氓。