前端常见算法

1、冒泡,数组相邻两个比较，前面大于后面的交换位置，记录最后交换的位置，此位置以后的都是排好序的。

N个数字要排序完成，外层循环N-1趟，每i趟循环（n-i）次，用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数

function bubble(arr) {
    if(!Array.isArray(arr) || arr.length <= 1) {
        return
    }
    let lastIndex = arr.length -1
    while(lastIndex > 0) { // // 当最后一个交换的元素为第一个时，说明后面全部排序完 毕
        let flag = true,k = lastIndex
        for(j = 0; j < k; j++) {
            if(arr[j] > arr[j+1]) {
                lastIndex = j // 记录最后一次交换元素的位置
                flag = false
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
            }
        }
        if(flag) {
            break
        }
    }
}

冒泡排序有两种优化方式。

一种是外层循环的优化，我们可以记录当前循环中是否发生了交换，如果没有发 生交换，则说明该序列已经为有序序列了。 因此我们不需要再执行之后的外层 循环，此时可以直接结束。

 

一种是内层循环的优化，我们可以记录当前循环中最后一次元素交换的位置，该 位置以后的序列都是已排好的序列，因此下 一轮循环中无需再去比较。 优化后的冒泡排序，当排序序列为已排序序列时，为最好的时间复杂度为 O(n) 。 冒泡排序的平均时间复杂度为 O(n²) ，最坏时间杂度为 O(n²) ，空间复杂度 为 O(1) ，是稳定排序。

 

2、 请实现一个 add 函数，满足以下功能。

add(1); // 1
add(1)(2); // 3
add(1)(2)(3)； // 6
add(1)(2, 3); // 6
add(1, 2)(3); // 6
add(1, 2, 3); // 6

实现 1： 
function currying(fn, length) { 
    length = length || fn.length; // 注释 1 
    return function (...args) { // 注释 2 
        return args.length >= length // 注释 3 
            ? fn.apply(this, args) // 注释 4
            : currying(fn.bind(this, ...args), length - args.length) // 注释 5 
    }
} 

其中注释部分 
注释 1：第一次调用获取函数 fn 参数的长度，后续调用获取 fn 剩余参数的 长度
注释 2：currying 包裹之后返回一个新函数，接收参数为 ...args 
注释 3：新函数接收的参数长度是否大于等于 fn 剩余参数需要接收的长度 
注释 4：满足要求，执行 fn 函数，传入新函数的参数 
注释 5：不满足要求，递归 currying 函数，新的 fn 为 bind 返回的新函数（bind 绑定了 ...args 参数，未执行），新的 length 为 fn 剩余参数的长度

实现 2： 
const currying = fn => {
    judge = (...args) => {
        args.length >= fn.length 
            ? fn(...args) 
            : (...arg) => judge(...args, ...arg)
    }
}