1. 求数组最大值和最小值之差

方法一：使用归并方法reduce (ES5)

API:array.reduce(function(prev, cur,index, array), initialValue);
reduce方法有两个参数：

• 第一个参数：在每一个项上调用的函数

  该函数有四个参数：

  • prev：初始值
  • cur：当前元素
  • index：当前元素的索引
  • array：当前元素所属的数组对象

• 第二参数：作为归并基础的初始值（可选）

代码实现：

var arr = [567, 45, 3, 3, 6, 2, 7, 234, 56];

function getMaxSubMin(arr) {
    Array.prototype.max = function () {
        return this.reduce(function (preValue, curValue, index, array) {
            return preValue > curValue ? preValue : curValue;
        })
    }
    Array.prototype.min = function () {
        return this.reduce(function (preValue, curValue, index, array) {
            return preValue > curValue ? curValue : preValue;
        })
    }
    return arr.max() - arr.min();
};
console.log(getMaxSubMin(arr));//565

方法二：使用内置函数的数学方法Math.max()和Math.min()

代码：

var arr = [567, 45, 3, 3, 6, 2, 7, 234, 56];

function getMaxSubMin(arr) {
    Array.prototype.max = function () {
        return Math.max.apply({}, this);
    };
    Array.prototype.min = function () {
        return Math.min.apply({}, this);
    };
    return arr.max() - arr.min();
};
console.log(getMaxSubMin(arr)); //565

2. 日期格式的数组如何排序

代码：

var dateArr = ['2018-01-20', '2017-02-19', '2016-08-08', '2018-12-09'];

function sortByDate(dateArr) {
    dateArr.sort(function (a, b) {
        return Date.parse(b.replace(/-/g, "/")) - Date.parse(a.replace(/-/g, "/"));
    });
    return dateArr;
}
console.log(sortByDate(dateArr));
/* [ 
'2018-12-09',
'2018-01-20',
'2017-02-19',
'2016-08-08' ] */

3. 调用'abcd'.f()将字符串'abcd'格式化成'd-c-b-a'

String.prototype.f = function () {
    return this.split("").reverse().join("-");
}
console.log('abcd'.f());//'d-c-b-a'

4. 为所有数组对象添加一个findDuplicate(n)方法，用于返回该数组中出现频率>=n的元素列表

Array.prototype.findDuplicate = function (count) {
    return this.reduce((re, val) => {
        let index = re.findIndex(o => o.val === val)
        if (index >= 0) {
            re[index].count++
        } else {
            re.push({
                count: 1,
                val
            })
        }
        return re
    }, []).filter(o => o.count >= count).map(o => o.val)
};

var arr = [1, 2, 3, 3, 4, 4, 4, 4, 4, 4];
console.log(arr.findDuplicate(4));

5. 尾递归优化计算Fibonacci数列

function Fib(n, ac1 = 1, ac2 = 1) {
    if (n <= 1) {
        return ac2;
    };
    return Fib(n - 1, ac2, ac1 + ac2);
}

6. 封装一个repeat函数，调用repeatFunc("hellworld")，会console.log4次hello world，每次间隔3秒

function repeat(func, times, wait) {
    return function () {
        var arg = arguments;
        var handle = function (i) {
            setTimeout(function () {
                func.apply(null, arg);
            }, wait * i)
        }
        for (let i = 0; i < times; i++) {
            handle(i);
        }
    }
}
var repeatFunc = repeat(console.log, 4, 3000);
repeatFunc("hellworld");

7. 输出一个数组中第N大的数据

使用堆排序实现，该实现只需循环k次。非常适合内存有限、数据海量的情况。时间复杂度：O（N * log2K）

function topKOfArr(k, arr) {
    function swap(a, b) {
        var t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }
    var i, j;
    for (i = arr.length; i > arr.length - k; i--) {
        for (j = Math.floor(i / 2) - 1; j >= 0; j--) {
            if (arr[j] < arr[2 * j + 1]) {
                swap(j, 2 * j + 1);
            }
            if (2 * j + 2 < i && arr[j] < arr[2 * j + 2]) {
                swap(j, 2 * j + 2);
            }
        }
        swap(i - 1, 0);
    }
    console.log(arr.length - k);
    return arr.slice(arr.length - k, arr.length - k + 1);
}

var arr = [1, 4, 6, 8, 99, 77, 56, 10, 25, 20],
    k = 5;
console.log(topKOfArr(k, arr)); //[ 20 ]

8. 实现一个快排

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    var pivotIndex = Math.floor(arr.length / 2);
    //找基准，并把基准从原数组删除
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] <= pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}
var arr = [12, 34, 45, 65, 1, 2, 3];
console.log(quickSort(arr));

9. 给定一个数组，找出大于零的且不在数组中的最小的那个数