前端面试算法题

1. 
//数组去重的方法
let arr = [1,2,5,3,4,2,9,6,4,4];
let unique = function(arr){
    let hashTable = {};
    let data = [];
    for(let i=0;i<arr.length;i++){
        //这是判断条件（已经存在，就不执行；若不存在则执行，且把元素加入到该对象中）
        if(!hashTable[arr[i]]){
            //让hashTable对象包含arr[i]这个元素
            hashTable[arr[i]] = true;
            //把不重复的元素添加到data数组中
            data.push(arr[i]);
        }
    }
    return data;
}
console.log(unique(arr));

简便方法：写原型方法；

Array.prototype.unique=function(){
    var n=[];//一个临时数组
    for(var r=0;r<this.length;r++){
        if(n.indexOf(this[r])==-1)
            n.push(this[r]);
    }
    return n;
  }

2.//检测一个字符串中，哪个字符出现的次数最多

方法一：：//思路就是，把字符串遍历一下，把每个字符和每个字符分别出现的次数以键值对的形式添加到一个对象里
//然后再分别拿出每个键值进行比较；

let str1 = 'abcdefgwaaabbrr';
function findMaxDuplicateChar(str){
    if(str.length === 1){
        return str;
    }
    //定义一个空对象，来装每个字符出现的次数
    let charObj = {};
    for(let i=0;i<str.length;i++){
        if(!charObj[str.charAt(i)]){
              charObj[str.charAt(i)] = 1;
              console.log(charObj);
        }else{
            console.log(charObj[str.charAt(i)]);
            charObj[str.charAt(i)] += 1;
        }
    }
    //定义一个变量来接收出现次数最多的字符
    let maxChar = '';
    //定义出现最多的次数
    let maxValue = 1;
    for(let k in charObj){
        if(charObj[k] >= maxValue){
            maxChar = k;
            maxValue = charObj[k];
        }
    }
    return maxChar;
}

let res = findMaxDuplicateChar(str1);
console.log(res);
方法二：： 

// 查找字符串中出现次数最多的字符和次数
var strr = 'flsffjdlfjlsjfdkljfdljfdklnnv';
var max = 0;
var maxStr = '';
function search(str){
// 先声明一个空对象，装分组好的字符
var obj = {};
// 第一个循环把相同字符分别以键值对的形式添加到obj对象中
for(var i=0;i<str.length;i++){
　　if(!obj[str[i]]){
　　　　obj[str[i]] = str[i];
　　}else{
　　　　obj[str[i]] += str[i];
　　}
}

console.log(obj);
// 第二个循环用来遍历obj对象，把里边的属性值length最大的元素取出
for(j in obj){
　　if(obj[j].length>max){
　　max = obj[j].length;
　　maxStr = j;
}
}
console.log(max);
console.log(maxStr);
}
search(strr);

//冒泡排序

let arr2 = [10,11,20,5,22,6];
function bubbleSort(arr){
    for(let i=0;i<arr.length-1;i++){
        for(let j=i+1;j<arr.length;j++){
            if(arr[j]>arr[i]){
                let temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
    }
    return arr;
}
let result = bubbleSort(arr2);
console.log(result);

4. 
　　//获取指定范围的随机数
　　function getRadomNum(min,max){

　　　　return Math.floor(Math.random() * (max - min + 1)) + min;

　　}

5. 

//随机生成指定长度的字符串
function randomString(n){
    let str = 'abcdefghijklmnopqrstuvwxyz0123456789';
    let resStr = '';
    for(let i=0;i<n;i++){
        //从str中随机取n次字符，进行拼接
        // resStr += str[Math.floor(Math.random() * str.length)];
        //返回匹配索引的字符
        resStr += str.charAt(Math.floor(Math.random() * str.length));
    }
    return resStr;
}
let resultStr = randomString(10);
console.log(resultStr);

6.

let arr3 = [10,3,6,11,20];
//找出数组中的最大差值
function getMaxProfit(arr){
    //先定义最小值为数组的第一个元素
    let minPrice = arr[0];
    //定义最大值为0
    let maxProfit = 0;
    for(let i=0;i<arr.length;i++){
        //当前数组值
        let currentPrice = arr[i];
        //当前的跟上次比较的最小值相比较，再取其中较小值
        minPrice = Math.min(minPrice,currentPrice);
        //算出当前数组值 和 目前判断最小值的差
        let potentialProfit = currentPrice - minPrice;
        //比较当前计算的差值跟上次取的差值最小值，那个小，取小的那个
        maxProfit = Math.max(maxProfit,potentialProfit);
    }
    //遍历完成，返回差值
    return maxProfit;
}

let resultProfit = getMaxProfit(arr3);
console.log(resultProfit);