前端知识梳理与总结（四）--面试常见问题之JS算法

1.写一个简单的函数，要求返回一个布尔值，指明字符串是否为回文结构。

function isPal(str) {
    str = str.replace(/\w/g, '').toLowerCase();
    return (str == str.split('').reverse().join(''));
}

2.数组扁平化（将嵌套的数组展开）

• 循环递归

function flatten(origin) {
    var result = [];
    for(var i = 0; i< origin.length; i++) {
        var item = origin[i];
        if(Array.isArray(item)) {
            result = result.concat(flatten(item))
        } else {
            result.push(item);
        }
    }
    return result;
}

• some + 扩展运算符

function flatten(origin) { while(origin.some(item=> Array.isArray(item))) {
        origin = [].concat(...origin);
    } return origin;
}

3.二分查找（递归遍历）

//js二分查找
//arr为某个数组，low为次数组的最小0，最大为数组的长度arr.length, key为要查找的值
function search(arr, low, high, key) {
    if (low > high) {
        return -1;
    }
    var mid = Math.floor((low + high) / 2); //选取的数组的索引值
     if (arr[mid] == key) {
         return mid;
     } else if (arr[mid] < key) {
        low = mid + 1;
        return search(arr, low, high, key);
     } else {
         high = mid - 1;
         return search(arr, low, high, key);
     }
}

4.清除字符串前后的空格

 //清除字符串前后的空格
 function trim(str) {
   if (str && typeof str === "string") {
       return str.replace(/^\s+ | \s+$/g, "");
    }
}
var str = "   ffegdd   ";
var result = trim(str);
console.log(result);

5.数组去重

// 最简单数组去重法
/*
* 新建一新数组，遍历传入数组，值不在新数组就push进该新数组中
* IE8以下不支持数组的indexOf方法
* */
function uniq(array){
    var temp = []; //一个新的临时数组
    for(var i = 0; i < array.length; i++){
        if(temp.indexOf(array[i]) == -1){
            temp.push(array[i]);
        }
    }
    return temp;
}

6.快速排序

//快速排序
function quickSort(arr·) {
    if (!arr instanceof Array) {
        return;
    }
    if (arr.length <= 1) {
        return arr;
    }
    var left =[];
    var right = [];
    var mid = Math.floor(arr.length / 2); //获取中间数的索引
    var value = arr.splice(mid, 1); //获取中间数值
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < value) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat(value, quickSort(right));
}

7.找出字符串中出现次数最多的字符及出现次数

8.手写一个深拷贝

• 递归法：

//使用递归的方式实现数组、对象的深拷贝
function deepClone(obj) {
    //判断拷贝的要进行深拷贝的是数组还是对象，是数组的话进行数组拷贝，对象的话进行对象拷贝
    var objClone = Array.isArray(obj) ? [] : {};
    if (obj && typeof obj === "object") {
        for (let key in obj) {
            if (obj.hasOwnProperty(key)) {
                if (obj[key] && typeof obj[key] === "object") {
                    objClone[key] = deepClone(obj[key]);
                } else {
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
}

• JSON 对象法：

//通过js的内置对象JSON来进行数组对象的深拷贝
function deepClone(obj) {
    var tmp = JSON.stringify(obj);
    var objClone = JSON.parse(tmp);
    return objClone;
}

• lodash函数库实现深拷贝，lodash.cloneDeep()实现深拷贝

9…给定arr1 arr2，合并去重，返回result

var concat_ = function(arr1,arr2){
	//不要直接使用var arr = arr1，这样arr只是arr1的一个引用，两者的修改会互相影响
	var result = arr1.concat();
	//或者使用slice()复制，var arr = arr1.slice(0)
	for(var i=0;i<arr2.length;i++){
		result.indexOf(arr2[i]) === -1 ? result.push(arr2[i]) : 0;
	}
	return result ;
}

10.冒泡排序

function bSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len-1; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
         // 相邻元素两两对比，元素交换，大的元素交换到后面
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
  }
  return arr;
}

11.求两个数的最大公约数

12.求两个数的最小公倍数

13.用两个栈实现队列

var stack1=[]; 
var stack2=[];
function push(node)
{
    stack1.push(node);
}
function pop()
{
    if (stack1.length === 0 && stack2.length === 0) return;
    if (stack2.length === 0){
        for (var i= stack1.length; i > 0; i--){
            stack2.push(stack1.pop());
        }
    }
    return stack2.pop();
}