前端面试题，写出一个快速找出两个数组不一样值的函数。

时间复杂度的定义

通常状况下，算法中基本操做重复执行的次数是问题规模n的某个函数，用T(n)表示，如有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记做T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度(O是数量级的符号)，简称时间复杂度。

求法

若是lim(T(n)/f(n))的值为不等于0的常数，则称f(n)是T(n)的同数量级函数。记做T(n)=O(f(n))。

实现方法

这篇文章讨论两种不一样时间复杂度的实现方法

方法一

function findDifferentElements1(array1, array2) {
    // 先对两个数组进行去重操做。基本操做次数2n(最糟糕的状况)。
    const arrayA = Array.from(new Set(array1))
    const arrayB = Array.from(new Set(array2))
    // 定义一个数组A，B内必定不存在的变量 SAME_ELE 。基本操做次数1
    const SAME_ELE = Symbol('$$__SAME__ELE__TAG')
    // 提早取出数组长度常数。基本操做次数2
    const lengthA = arrayA.length
    const lengthB = arrayB.length
    // 用两层 for 循环嵌套检查出每个相同的元素。基本操做次数 3n^2 + 4n + 2
    for(let i = 0; i < lengthA; i++ ){ // n次i比较 n次i++ 初始化i记一次 一共操做2n+1次
        for(let j = 0; j < lengthB; j++) { // n次j比较 n次j++ 初始化j记一次 一共操做2n+1次
            if(arrayA[i] === arrayB[j]){ // 基本操做次数1(外层循环n*n次)
                // 而后用 splice 函数将相同的元素替换成SAME_ELE。
                arrayA.splice(i,1,SAME_ELE) // 基本操做次数1(外层循环n*n次)
                arrayB.splice(j,1,SAME_ELE) // 基本操做次数1(外层循环n*n次)
                //break (实际上能够用break优化，这里不讨论break优化的状况)
            }
        }
    }
    // 合并两个数组而后将数组内全部的 SAME_ELE 去掉，留下的就是不一样的元素了。基本操做次数2n+1
    return Array.prototype.concat(arrayA,arrayB).filter(item=>item!==SAME_ELE)
}
复制代码

时间复杂度分析

这个函数前面定义了5个变量基本操做数为2n+3。

接下来是两个for循环嵌套，假设两个数组的长度都是n，那么第一个for循环须要运行n次，第二个for循环在最坏的状况下也要运行n次，也就是说被这两个for循环包裹起来的基本操做将会被重复运行n*n次，被包裹起来的代码一共有3条语句，加上for循环自己有4n次操做因此一共有3*n*n+4n次基本操做。接下来的return语句是一个复合语句concat基本操做记为n，filter的基本操做记为n，那么整个函数的基本操做函数

T(n) = 4n^2+8n+6 .

令 f(n) = T(n) 的数量级。

lim(T(n)/f(n)) = k {k|k≠0,k∈常数}

f(n) = n^2 （口诀是去掉常数项和低次幂项以及去掉最高次幂项的系数）

T(n) = O(n^2)

方法二

function findDifferentElements2(array1, array2) {
    // 定义一个空数res组做为返回值的容器，基本操做次数1。
    const res = []
    // 定义一个对象用于装数组一的元素，基本操做次数1。
    const objectA = {}
    // 使用对象的 hash table 存储元素，而且去重。基本操做次数2n。
    for(const ele of array1) { // 取出n个元素n次
        objectA[ele] = undefined // 存入n个元素n次
    }
    // 定义一个对象用于装数组二的元素，基本操做次数1。
    const objectB = {}
    // 使用对象的 hash table 存储元素，而且去重。基本操做次数2n。
    for(const ele of array2){ // 取出n个元素n次
        objectB[ele] = undefined // 存入n个元素n次
    }
    // 使用对象的 hash table 删除相同元素。基本操做次数4n。
    for(const key in objectA){ //取出n个key (n次操做)
        if(key in objectB){ // 基本操做1次 (外层循环n次)
            delete objectB[key] // 基本操做1次 (外层循环n次)
            delete objectA[key] // 基本操做1次 (外层循环n次)（总共是3n 加上n次取key的操做 一共是4n）
        }
    }
    // 将第一个对象剩下来的key push到res容器中，基本操做次数是3n次(最糟糕的状况)。
    for(const key in objectA){ // 取出n个元素n次(最糟糕的状况)。
        res[res.length] = key // 读取n次length n次，存入n个元素n次，一共2n(最糟糕的状况)。
    }
    // 将第二个对象剩下来的key push到res容器中，基本操做次数也是3n次(最糟糕的状况)。
    for(const key in objectB){ // 取出n个元素n次(最糟糕的状况)。
        res[res.length] = key // 读取n次length n次，存入n个元素n次，一共2n(最糟糕的状况)。
    }
    // 返回结果，基本操做次数1。
    return res
}
复制代码

时间复杂度分析

改进后的函数基本操做次数算起来很是简单，注释写的很清楚了，因此

T(n) = 14n+7 。

令 f(n) = T(n) 的数量级。

lim(T(n)/f(n)) = k {k|k≠0,k∈常数}

f(n) = n (去掉常数项和低次幂项以及去掉最高次幂项的系数)

T(n) = O(n)

预测具体差距

当n趋于无穷大的时候

算法1应该比算法2的性能慢 O(n^2)/O(n) 倍

=> O(n) 慢 n 倍

测试 当n=100时的耗时状况

// 定义两个数组
const array1 = []
const array2 = []
// 数据量为100
const n = 100
// 初始化
for(let i = 0; i < n; i++){
    array1.push(i)
    array2.push(n - i) // 这两个数组中相同的元素距离相距都比较远，算是比较接近糟糕的状况的但也不是时最糟糕的状况。
}
// 开始测试第一个方法耗时
console.time()
const res1 = findDifferentElements1(array1,array2)
console.timeEnd()
console.log(res1)
// 开始测试第二个方法耗时
console.time()
const res2 = findDifferentElements2(array1,array2)
console.timeEnd()
console.log(res2)
复制代码

当n=100时的耗时结果

相差15倍

当n=1000时的耗时结果

相差128倍

当n=10000时的耗时结果

相差1148倍