玩转算法(一)——时间复杂度

数据规模

public class NumScale {	
	public static void main(String[] args) {	    	  
	    for(int x = 0; x < 10; x++) {	    	
	    	double n = Math.pow(10, x);	    
	    	long startTime = System.currentTimeMillis();	    
	    	int sum = 0;	    	
	    	for(int i = 0; i < n; i++)
	    		sum += i;	    	
	    	long endTime = System.currentTimeMillis();	    	
	    	System.out.println("10^" + x + ":" + (endTime-startTime) + "ms" );	    
	    }
	}
}

输出：

10^0:0ms
10^1:0ms
10^2:0ms
10^3:0ms
10^4:0ms
10^5:1ms
10^6:3ms
10^7:15ms
10^8:157ms
10^9:1486ms

由于上面案例的单条指令计算比较简单，所以可以将处理数据的级别降低一个指数。O(nlogn)处理10^6级别。

对10^5的数据进行选择排序，计算机可能出现假死。

递归算法的时间复杂度

每次的递归函数时间复杂度为T，递归的深度为H，则整个时间复杂度为T * H。

下方的指数运算，从一般的O(n)级别使用递归优化到了O(logn)。

第一层为O(2⁰)，第二层为O(2¹)，第三层为O(2²)，第n层为O(2^n-1)。

总共深度为n层，则总的时间复杂度达到了O(2ⁿ)，变为指数增长。

归并算法，每层处理的数据都是n个，每层都是O(n)，但是深度为logn，所以整体时间复杂度为O(nlogn)。

均摊时间复杂度

动态数组：当数组满了，会进行扩容操作。增加一个数据，时间复杂度为O(1)。

将原来数组的数据复制到扩容后的新数组，时间复杂度为O(n)。

但是要达到扩容的条件需要增加n个数据，O(n)均摊到每个数据，相当于每增加一个数据时间复杂度为O(2)。

会出现一个问题：数组容量为2n，不断的在索引为n的这个临界点，删除，添加。则会不断地扩容和缩容。无法均摊。

解决办法：当元素个数为数组的1/4时，才进行缩容操作。缩容为原数组的1/2。