前端算法集锦

这次腾讯面试的失利，让我深刻明白了这一点：想进大公司，必须把算法学习好。为此开一篇文章，记录下面试过程中经常会出现的算法笔试题。

Q1. 去掉一组整型数组中重复的值

该题目的解法有好几种，下面列举几种常见的解法。

Object.assign(Array.prototype, {
    unique() {
        let newArr = [this[0]]; 
        for(let i of Object.keys(this)) {
            let value = this[i];
            if (newArr.indexOf(value) === -1) {
                newArr.push(value);
            }
        }
        return newArr;
    }
});

上面那种解法是我们最容易想到的解法，在查找重复元素的过程中使用了indexOf方法，如果不使用的话，也可以使用循环解决如下：

Object.assign(Array.prototype, {
    unique() {
        let newArr = [this[0]]; 
        for(let i of Object.keys(this)) {
            let value1 = this[i];
            let repeat = false;
            for(let j of Object.keys(newArr)) {
                let value2 = newArr[j];
                if (value1 === value2) {
                    repeat = true;
                    break;
                }
            }
            if (!repeat) {
                newArr.push(value1);
            }
        }
        return newArr;
    }
});

除了使用indexOf和循环去重，我们还可以使用Object对象判断是否重复，下面这种解法是作者比较推荐的一种解法。

Object.assign(Array.prototype, {
    unique() {
        let newArr = [this[0]]; 
        let obj = {
            [this[0]]: true
        };
        for(let i of Object.keys(this)) {
            let value = this[i];
            if (obj[value] === undefined) {
                obj[value] = true;
                newArr.push(value);
            }
        }
        return newArr;
    }
});

最后还有一种方法，使用了sort（）对数组进行了排序，这样去重之后原数组的索引对应元素的值都发生的变化，如果不考虑这一点，可以使用这种解决方案。

Object.assign(Array.prototype, {
    unique() {
        this.sort();
        let newArr = [this[0]]; 
        for(let i of Object.keys(this)) {
            let value = this[i];
            if (value !== newArr[newArr.length - 1]) {
                newArr.push(value);
            }
        }
        return newArr;
    }
});

Q2. 统计一个字符串出现最多的字母

其实就是统计字符串中每个字符出现的次数，最后从中找到出现次数最多的字符。

Object.assign(String.prototype, {
    findMaxDuplicateChar() {
        if (str.length == 1) {
            return str;
        } 
        let charObj = {};
        for(let i of Object.keys(this)) {
            let c = this[i];
            if (charObj[c] === undefined) {
                charObj[c] = 1;
            } else {
                charObj[c]++;
            }
        }
        let maxChar = '';
        let maxNum = 0;
        for(let i of Object.keys(charObj)) {
            let num = charObj[i];
            if (num > maxNum) {
                maxNum = num;
                maxChar = i;
            }
        }
        return maxChar;
    }
});

Q3. 排序算法

冒泡排序

Object.assign(Array.prototype, {
    bubbleSort() {
        for(let i = 0, l = this.length;i < l - 1;i++) {
            for (let j = i + 1;j < l - 1;j++) {
                if (this[i] > this[j]) {
                    [this[i], this[j]] = [this[j], this[i]];
                }
            }
        }
    }
});

快速排序

let quickSort = arr => {
    if (arr.length <= 1) {
        return arr;
    }
    let pivotIndex = Math.floor((arr.length - 1) / 2);
    let pivot = arr.splice(pivotIndex, 1)[0];
    let left = [];
    let right = [];
    for (let i of Object.keys(arr)) {
        let v = arr[i];
        if (v <= pivot) {
            left.push(v);
        } else {
            right.push(v);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}

插入排序

let searchIndex = (arr, x) => {
    if (x <= arr[0]) {
        return 0;
    }
    if (x >= arr[arr.length - 1]) {
        return arr.length;
    }
    let i = 0;
    for (;i < arr.length;i++) {
        if (arr[i] <= x && x <= arr[i+ 1] ) {
            break;
        }
    }
    return i + 1;
}
let insertSort = arr => {
    let sortArr = [arr[0]];
    for (let i = 1;i < arr.length;i++) {
        let index = searchIndex(sortArr, arr[i]);
        sortArr.splice(index, 0, arr[i]);
    }
    return sortArr;
}

Q4. 斐波那契数列

斐波那契数列就是形如0,1,1,2,3,5,8.....的数列。

let getFibonacci = n => {
    let arr = [];
    for(let i = 0;i < n - 1;i++) {
        if (i <= 1) {
            arr.push(i);
        } else {
            arr.push(arr[i - 1] + arr[i - 2]);
        }
    }
    return arr;
}

Q5. 速度创建1-100的数组

ES5的写法

var a = Array.prototype.map.call(Array(101).join('0').split(''), function() {
    return arguments[1] + 1;
});

ES6的写法

let arr = Array.from(Array(100), (value, index) => index + 1);//from会将空位转成undefined
//或者
let arr = Array.from({length: 100}, (value, index) => index + 1);

Q6. 洗牌算法

这道题是我去富途面试CTO问我的一道题，我听到之后一脸懵比（后面的题目也做的不好），结果直接game over，面试之后查阅了下百度自己写了出来

let swap = a => {
  let b = [];
  for(var i = a.length;i > 0;) {
        var index = Math.floor(Math.random() * i);
    b.push(a[index]);
    a[index] = a[--i];
  }
  return b;
}