JS: 算法时间复杂度分析

语句频度：设 n 为求解的问题的规模，基本操作（或语句）执行次数总和称为语句频度，记做f(n)。

时间复杂度：算法（或程序）中基本操作（或语句）重复执行的次数总和称为时间复杂度，记做T(n)，且有T(n) = O(f(n)) 。

求时间复杂度步骤：
1. 去掉f(n)中所有加法常数
2. 只保留最高阶项

举例：

function plus1(num){
	console.log(num);  	// 1
	num++				// 1
	console.log(num); 	// 1
}

语句频度： f(n) = 1 + 1 + 1 = 3
时间复杂度：T(n) = O(f(n)) = O(3) = O(1)
O(1)称为常量数量级

function sum(arr){
	var s = 0;					// 1
	var l = arr.length			// 1
	for(var i = 0; i < l; i++){	// n
		s += arr[i];			// n
	}
	console.log(s);				// 1
}

语句频度： f(n) = 1 + 1 + n + n + 1 = 2n + 3
时间复杂度：T(n) = O(f(n)) = O(2n+3) = O(n)
O(n)称为线性数量级

function square(n){
	var s = 0;						// 1
	for(var i = 0; i < n; i++){		// n
		for	(var j = 0; j < n; j++){// n*n
			s++						// n*n
		}
	}
	console.log(s);					// 1
}

语句频度： f(n) = 1 + n + n² + n² + 1 = 2n² + n + 2
时间复杂度：T(n) = O(f(n)) = O(2n² + n + 2) = O(n²)
O(n²)称为平方数量级

常见的时间复杂度：
O(1)<O(log₂n)<O(n)<O(nlog₂n)<O(n²)<O(n³)<O(2ⁿ)

log₂n:
以2为底，n的对数，
对数是对求幂的逆运算，
即 2 的多少次方结果为 n，
如log₂1 = 0，log₂2 = 1，log₂4 = 2， log₂8 = 3等。

以冒泡排序为例：

function sort(arr){
	var l = arr.length;     			// 1
	var tmp;							// 1
	for(var i = 0; i < l; i++){			// n-1
		for(var j = 0; j < l - i; j++){	// n(n-1)/2 
			if(arr[j]> arr[j+1]){		// n(n-1)/2
				tmp = arr[j+1];		// 0到n(n-1)/2
				arr[j+1] = arr[j]	// 0到n(n-1)/2		
				arr[j] = tmp		// 0到n(n-1)/2						
			}	
		}
	}
	console.log(arr)					// 1
}

语句频度：
最好情况：f(n) = 2 + (n-1) + n(n-1) + 1 = n² + 2
最坏情况：f(n) = 2 + (n-1) + 5n(n-1)/2 + 1 = 5n²/2-3n/2+3
时间复杂度：
最好情况： T(n) = O(f(n)) = O(n² + 2) = O(n²)
最坏情况：T(n) = O(f(n)) = O(5n²/2 - 3n/2 + 3) = O(n²)
最好最坏情况时间复杂度相同，都是O(n²)。

// 优化冒泡算法
// 通过hasChanged标记判断是否已经排序完成来避免无效操作
function sort(arr){
	var l = arr.length;     			// 1
	var tmp;							// 1
	var i = 0;							// 1
	var hasChanged;    					// 1
	while(!hasChanged && i < l)			// 1到n-1
		hasChanged = false;				// 1到n-1
		for(var j = 0; j < l - i; j++){ // n-1到n(n-1)/2
			if(arr[j]> arr[j+1]){	// n-1到n(n-1)/2
				tmp = arr[j+1];	 	// 0到n(n-1)/2
				arr[j+1] = arr[j]	// 0到n(n-1)/2
				arr[j] = tmp		// 0到n(n-1)/2
				hasChanged = true;	// 0到n(n-1)/2
			}	
		}
		i++;							// 1到n-1
	}
	console.log(arr)					// 1
}

语句频度：
最好情况：f(n) = 8 + 2(n-1) + 2 = 2n + 6
最坏情况：f(n) = 4 + 3(n-1) + 3n(n-1) + 1 = 3n²+2
时间复杂度：
最好情况： T(n) = O(f(n)) = O(2n + 6) = O(n)
最坏情况：T(n) = O(f(n)) = O(3n²+2) = O(n²)
最好情况的时间复杂度得到提升，但是一个算法的时间复杂度有最坏情况决定，因此仍然是O(n²)。