前端面试必备——十大经典排序算法 about cv

[Wscats]

TF-IDF与余弦相似性的应用（二）：找出相似文章

[Wscats]

时间换空间以及空间换时间

两个数字进行交换

//时优 运用空间而减少了时间的使用
function swap(a, b) {
	var c;
	c = a;
	a = b;
	b = a;
}
//空优 运用时间而减少了空间的使用
function swap(a, b) {
	a = a + b;
	b = a - b;
	a = a - b;
}

数组去重，也是一个典型的用空间换时间的例子

function unique(arr) {
	var obj = {}
	var result = []
	for(var i in arr) {
		if(!obj[arr[i]]) {
			obj[arr[i]] = true;
			result.push(arr[i]);
		}
	}
	return result;
}

字符串中判断出现次数最多的那个字母，这个跟数组去重原理一样，用一个对象记录值得出现次数，然后再遍历对象寻找出现次数最大的那个字母

function findMaxDuplicateChar(str) {
    // 记录字母出现次数
    let charObj = {};
    for (let i = 0; i < str.length; i++) {
        if (!charObj[str[i]]) {
            charObj[str[i]] = 1;
        } else {
            charObj[str[i]] += 1;
        }
    }
    // 判断次数最多的字母
    let maxChar = '',
        maxValue = 1;
    for (var k in charObj) {
        if (charObj[k] >= maxValue) {
            maxChar = k;
            maxValue = charObj[k];
        }
    }
    return maxChar;
}
var str = 'afjghdfraaaasdenas';
var maxChar = findMaxDuplicateChar('afjghdfraaaasdenas');

[Wscats]

算法的效率

算法的效率主要由以下两个复杂度来评估：

复杂度	描述
时间复杂度	评估执行程序所需的时间。可以估算出程序对处理器的使用程度
空间复杂度	评估执行程序所需的存储空间。可以估算出程序对计算机内存的使用程度
常见的时间复杂度，按数量级递增排列依次为：

下面引用算法(一)时间复杂度的图来表示各种时间复杂度

• 常数阶O(1)
• 对数阶O(log2n)
• 线性阶O(n)
• 线性对数阶O(nlog2n)
• 平方阶O(n^2)
• 立方阶O(n^3)
• k次方阶O(n^k)
• 指数阶O(2^n)

推导大O阶技巧

推导大O阶，我们可以按照如下的规则来进行推导，得到的结果就是大O表示法，例如2 n ^ 2 + 3 n + 3

1. 用常数1来取代运行时间中所有加法常数 //2 n ^ 2 + 3 n + 1
2. 修改后的运行次数函数中，只保留最高阶项 //2 n ^ 2
3. 如果最高阶项存在且不是1，则去除与这个项相乘的常数。 //n ^ 2

常数阶

比如高斯算法，经典的1+2+3+...99+100的和

var sum = 0, n = 100; //执行一次  
sum = (1 + n) * n / 2; //执行一次  
console.log(sum); //执行一次

因为总共运行三次，这个算法的时间复杂度：O(3)，但一般记作O(1)

下面我们看另外一个算法

var i, sum = 0, n = 100; //执行1次
for(i = 1; i <= n; i++) { //执行 n+1次 
	sum = sum + i; //执行n次 
}
console.log(sum); //执行1次 

这个跟上面不同的是中间用了一个for循环的方法，所以算法的执行次数为1 + ( n + 1 ) + n + 1 = 2n + 3
上述算法的执行总次数（所需时间）会随着 n 的增大而增加，但是在for循环以外的语句并不受n的规模影响（永远都只执行一次）。所以我们可以将上述算法的执行总次数简单的记做： 2n或者简记n
这样我们就得到了我们设计的算法的时间复杂度，我们把它记作：O(n)
从感官上我们就不难看出，从算法的效率上看，O(1)<O(n)的，所以高斯的算法更快，更优秀。

线性阶

for(var i = 0; i < n; i++) {
	//时间复杂度为O(1)的算法
	...
}

上面算法循环体中的代码执行了n次，因此时间复杂度为O(n)

对数阶

对数阶时间复杂度会越来越小

var number = 1;
while(number < n) {
	number = number * 2;
	//时间复杂度为O(1)的算法
	...
}

可以看出上面的代码，随着number每次乘以2后，都会越来越接近n，当number不小于n时就会退出循环。假设循环的次数为X，则由2^x=n得出x=log₂n，因此得出这个算法的时间复杂度为O(logn)

平方阶

for循环是要阶乘的

for(var i = 0; i < n; i++) { //执行 n+1次 
	for(var j = 0; j < n; i++) { //执行 n+1次 
		//复杂度为O(1)的算法
		...
		//执行 n次 
	}
}

时间复杂度如下( n + 1)(n + 1 + n) = 2 n ^ 2 + 3 n + 1，因为只保留最高阶，所以系数和常数都被去掉，所以时间复杂度为O(n²)

参考文档

• 算法(一)时间复杂度
• 如何计算时间算法复杂度

[Wscats]

leetcode