原文链接：blog.csdn.net/weixin_3964…
一、算法概念
算法是指对特定问题求解步骤的一种描述。它不依赖于任何语言，既可以用自然语言、程序设计语言描述，也可以用流程图、框图来表示。
二、特性
- 有穷性：算法是由若干条指令组成的有穷序列，总是在执行若干次后结束，不可能永不停止。
- 确定性：每条语句有确定的含义，无歧义。
- 可行性：算法在当前环境条件下可以通过有限次运算实现。
- 输入输出：有零个或多个输入，一个或多个输出。
三、好的算法
- 正确性：正确性是指算法能够满足具体问题的需求，程序运行正常，无语法错误，能够通过典型的软件测试，达到预期的需求。
- 易读性：算法遵循标识符命名规则，简洁易懂，注释语言恰当适量，方便自己和他人阅读，便于后期调试和修改。
- 健壮性：算法对非法数据及操作有较好的反应和处理。
- 高效性：运行效率高，即算法运行时间短。算法时间复杂度就是算法运行需要的时间。
- 低存储性：算法所需要的存储空间低。算法空间复杂度就是算法占用空间的大小。
四、时间复杂度
一个算法的执行时间与算法中语句的执行次数成正比，算法中的语句执行次数称为语句频度或时间频度，记为T( n )。
//算法一
sum=0; //运行1次
total=0; //运行1次
for(i=1; i<=n; i++) //运行n次
{
sum=sum+i; //运行n次
for(j=1; j<=n; j++) //运行n*n次
total=total+i*j; //运行n*n次
}
T (n) = 1+1+n+n+n*n+n*n = 2n^2+2n+2
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为一个不等于零的常数，则称f(n)是T(n)的同数量级函数。令T(n) = O(f(n))，称O(f(n)) 为 算法的渐进时间复杂度，简称时间复杂度。如：
//算法二
i=1; //运行1次
while(i<=n) //可假设运行x次
{
i=i*2; //可假设运行x次
}
上列中，我们无法立即确定while 及 i = i * 2 运行了多少次，每次运算后 i 值为 2，，…，，当 i = n 时结束，即 = n 时结束，则 x = log2n。时间复杂度为O( f(n) ) = O( log2n)。
五、空间复杂度
空间复杂度是对一个算法在运行过程中临时占用存储空间的大小度量。一个算法在计算机上所占用的空间由三部分组成：
- 输入/输出数据
- 算法本身所占用的空间
- 额外需要的辅助空间
swap ( int x , int y ) //x与y交换
{
int temp;
temp=x; //temp为辅助空间
x=y;
y=temp;
}
该算法只使用了一个辅助变量，就是常量，则空间复杂度为O(1)。
六、实例分析
示例代码：
decimal Factorial(int n)
{
if (n == 0)
return 1;
else
return n * Factorial(n - 1);
}
阶乘，给定规模n，需要执行n次，所以时间复杂度为O(n)，空间复杂度为O(n)
示例代码：
int FindMaxElement(int[] array)
{
int max = array[0];
for (int i = 0; i < array.Length; i++)
{
if (array[i] > max)
{
max = array[i];
}
}
return max;
}
这里，n 为数组 array 的大小，则最坏情况下需要比较 n 次以得到最大值，所以时间复杂度为 O(n)。只使用了一个辅助变量 max，所以空间复杂度为O(1)。
示例代码：
long FindInversions(int[] array)
{
long inversions = 0;
for (int i = 0; i < array.Length; i++)
for (int j = i + 1; j < array.Length; j++)
if (array[i] > array[j])
inversions++;
return inversions;
}
这里，n 为数组 array 的大小，则基本步骤的执行数量约为 n*(n-1)/2，所以时间复杂度为 O(n2)。没有使用辅助空间，空间复杂度为O(1)。
示例代码：
long SumMN(int n, int m)
{
long sum = 0;
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
sum += x * y;
return sum;
}
给定规模 n 和 m，则基本步骤的执行数量为 n*m，所以时间复杂度为 O(n2)。空间复杂度为O(1)。
示例代码：
decimal Sum3(int n)
{
decimal sum = 0;
for (int a = 0; a < n; a++)
for (int b = 0; b < n; b++)
for (int c = 0; c < n; c++)
sum += a * b * c;
return sum;
}
则基本步骤的执行数量约为 nnn ，时间复杂度为 O(n3)，空间复杂度为O(1)。
示例代码：
decimal Calculation(int n)
{
decimal result = 0;
for (int i = 0; i < (1 << n); i++)
result += i;
return result;
}
基本步骤的执行数量为 ，所以时间复杂度为 O()，空间复杂度为O(1)。
示例代码：
斐波那契数列：
fib（0） = 1；
fib（1） = 1；
fib（n） = fib（n-1） + fib（n-2）； n > 2
int Fibonacci(int n)
{
if (n <= 1)
return n;
else
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
Fib(n) 所需的时间为计算 Fib(n-1) 的时间和计算 Fib(n-2) 的时间的和。 T(n<=1) = O(1) T(n) = T(n-1) + T(n-2) + O(1) 最坏的情况下是一个满二叉树，执行次数为2n−1 − 1，所以时间复杂度为O()。 空间复杂度和深度有关，所以空间复杂度为O(n)。
示例代码：
int Fibonacci(int n)
{
if (n <= 1)
return n;
else
{
int* f = new int[n + 1];
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
{
f[i] = f[i - 1] + f[i - 2];
}
return f[n];
}
}
同样是斐波那契数列，我们使用数组 f 来存储计算结果，这样时间复杂度优化为 O(n)，空间复杂度为O(n)。
示例代码：
int Fibonacci(int n)
{
if (n <= 1)
return n;
else
{
int iter1 = 0;
int iter2 = 1;
int f = 0;
for (int i = 2; i <= n; i++)
{
f = iter1 + iter2;
iter1 = iter2;
iter2 = f;
}
return f;
}
}
同样是斐波那契数列，由于实际只有前两个计算结果有用，我们可以使用中间变量来存储，这样就不用创建数组以节省空间。同样算法时间度优化为 O(n)，空间复杂度为O(1)。
示例代码：
static int Fibonacci(int n)
{
if (n <= 1)
return n;
int[,] f = { { 1, 1 }, { 1, 0 } };
Power(f, n - 1);
return f[0, 0];
}
static void Power(int[,] f, int n)
{
if (n <= 1)
return;
int[,] m = { { 1, 1 }, { 1, 0 } };
Power(f, n / 2);
Multiply(f, f);
if (n % 2 != 0)
Multiply(f, m);
}
static void Multiply(int[,] f, int[,] m)
{
int x = f[0, 0] * m[0, 0] + f[0, 1] * m[1, 0];
int y = f[0, 0] * m[0, 1] + f[0, 1] * m[1, 1];
int z = f[1, 0] * m[0, 0] + f[1, 1] * m[1, 0];
int w = f[1, 0] * m[0, 1] + f[1, 1] * m[1, 1];
f[0, 0] = x;
f[0, 1] = y;
f[1, 0] = z;
f[1, 1] = w;
}
优化之后时间复杂度为O(log2n)，空间复杂度为O(1)。
