时间复杂度

时间复杂度

一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或「时间频度」。记为T(n)。

时间频度T(n)中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律，为此我们引入时间复杂度的概念。算法的时间复杂度也就是算法的时间度量，记作：T(n) = O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐进时间复杂度，简称「时间复杂度」。

这种表示方法我们称为「 大O符号表示法 」，又称为渐进符号，是用于描述函数渐进行为的数学符号。

常见的时间复杂度量级有：

• 常数阶$O(1)$
• 线性阶$O(n)$
• 平方阶$O(n^2)$
• 立方阶$O(n^3)$
• 对数阶$O(logn)$
• 线性对数阶$O(nlogn)$
• 指数阶$O(2^n)$

常用的时间复杂度所耗费的时间从小到大依次是：
$O(1)$< $O(logn)$ < $O(n)$< $O(n\ast logn)$ < $O(n^2)$ < $O(n^3)$ < $O(2^n)$ < $O(n!)$ <$O(n^n)$

常数阶$O(1)$
$O(1)$，表示该算法的执行时间（或执行时占用空间）总是为一个常量，不论输入的数据集是大是小，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是O(1)，如：

int i = 1;
int j = 2;
int k = i + j;

上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用$O(1)$来表示它的时间复杂度。

线性阶$O(n)$
$O(n)$，表示一个算法的性能会随着输入数据的大小变化而线性变化，如

for (int i = 0; i < n; i++) {
	 j = i;
   j++;
}

这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用$O(n)$来表示它的时间复杂度。

平方阶$O(n^2)$
$O(n²)$ 表示一个算法的性能将会随着输入数据的增长而呈现出二次增长。最常见的就是对输入数据进行嵌套循环。如果嵌套层级不断深入的话，算法的性能将会变为立方阶$O(n^3)$，$O(n^4)$，$O(n^k)$以此类推。

public class TS {
	public static void main(String[] args) {
		int sum = 0;
		for(int i=1;i<=100;i++) {
			for(int j=1;j<=100;j++)
				sum = sum + i;
		}
	}
}

外层i的循环执行一次，内层j的循环就要执行100次，所以外层执行100次，那么总的就需要执行100*100次，那么n次呢？就是n的平方次了。所以时间复杂度为：$O(n^2)$。

平方阶的另外一个例子：

public class TS {
	public static void main(String[] args) {
		int sum = 0;
		for(int i=1;i<=100;i++) {
			for(int j=i;j<=100;j++)
				sum = sum + i;
		}
	}
}

当i=1的时候执行n次，当n=2的时候执行（n-1）次，…

一直这样子下去就可以构造出一个等差数列：n+（n-1）+（n-2）+…+2+1

根据等差数列的求和公式：或者

求和易得：n+n*(n-1)/2整理一下就是n*(n+1)/2然后我们将其展开可以得到n^2/2+n/2。

根据我们的步骤走，保留最高次项，去掉相乘的常数就可以得到时间复杂度为：$O(n^2)$

指数阶$O(2^n)$
$O(2^n)$，表示一个算法的性能会随着输入数据的每次增加而增大两倍，典型的方法就是裴波那契数列的递归计算实现

裴波那契数列：800年前，意大利的数学家斐波纳契出版了惊世之作《算盘书》。在《算盘书》里，他提出了著名的“兔子问题”：假定一对兔子每个月可以生一对兔子，而这对新兔子在出生后第二个月就开始生另外一对兔子，这些兔子不会死去，那么一对兔子一年内能繁殖多少对兔子？

答案是一组非常特殊的数字：1，1，2，3，5，8，13，21，34，55，89……不难发现，从第三个数起，每个数都是前两数之和，这个数列则称为“斐波纳契数列”，其中每个数字都是“斐波纳契数”。

斐波纳契数列还暗含着许多有趣的数字规律，如从第3个数开始每隔两个必是2的倍数，从第4个数开始每隔3个必是3的倍数，从第5个数开始每隔4个必是5的倍数……另外，这个数列最具有和谐之美的地方是，越往后，相邻两项的比值会无限趋向于黄金比0.61803……即[5^(1/2)-1]/2。

但这个伟大的发现在当时一直不受数学们的青睐与认可，直到19世纪，斐波纳契数列才在该领域占有一席之地并引发出了许多重要的应用。像斐波纳契方块，斐波纳契螺旋以及斐波纳契数，在生活中都可以见到类似的图案，譬如说海螺和蜗牛壳等等。

public class DiGui {
    public static  void main(String[] args){
        //数列：1，1，2，3，5，8 ......
        System.out.print( f(6) );//输出数列的第几位
    }
    public  static int f(int n){
        if( n == 1 || n == 2 )
            return 1;
        else
            return f( n - 1 )+f( n - 2 );
    }
}

实现过程图解

对数阶$O(logn)$

int i = 1;
while(i<n)
{
    i = i * 2;
}

上面的代码，在 while 循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了，直到 i 不小于 n 退出。我们试着求解一下，假设循环次数为 x，也就是说 2 的 x 次方等于 n，则由 2^x=n 得出 x=log₂n。因此这个代码的时间复杂度为$O(logn)$

线性对数阶$O(nlogn)$
线性对数阶$O(nlogn)$，就是将时间复杂度为对数阶$O(logn)$的代码循环n遍的话，那么它的时间复杂度就是 n * $O(logN)$，也就是了$O(nlogn)$，如下:

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}

除此之外，其实还有平均情况复杂度、最好时间复杂度、最坏时间复杂度。一般没有特殊说明的情况下，都是值最坏时间复杂度。

参考文章：
时间复杂度到底怎么算
计算时间复杂度–（简单版）
Java递归方法算斐波那契数列的实现过程