javascript面试常见算法整理

- 高效率冒泡排序

/** 
 * 外层for循环控制循环次数
 * 内层for循环负责相邻两数交换位置,找到最大数,排到最后
 * 设置done标志位,减少不必要循环
*/
var arr = [1, 3, 4, 90, 8, 49, 0];
var max = arr.length - 1;
for (var j = 0; j < max; j++) {
    var done = true;
    // 这里可以根据外层的j 逐渐减少内层遍历        
    // 因为每次遍历置于最后的元素  
    // 不需要在参加遍历 [1, 3, 4, 0, 8, 49, 90]
    for (var i = 0; i < max - j; i++) {
        if (arr[i] > arr[i + 1]) {
            var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
            done = false;
        }
    }
    if (done) {
        break;
    }
}

- 快速排序

function quickSort(arr){
  if(arr.length<1){
    return arr;
  }
  var pivotIndex=Math.floor(arr.length/2);//找到那个基准数
  var pivot=arr.splice(pivotIndex,1)[0]; //取出基准数，并去除，splice返回值为数组。
  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)); //加入基准数
}
arr=[2,1,5,8,3,7,4,6,9];
console.log(quickSort(arr)); //[1, 2, 3, 4, 5, 6, 7, 8, 9]

- 数组去重的三种解决方法

function unique(arr) {
   var res = []; //声明目标数组
   for(var i=0;i<arr.length;i++) {
     for(var j=0;j<res.length;j++) {
       // 如果在目标数组中找到该重复元素则跳出循环
       if(arr[i].id===res[j].id) {
         break;
       }
     }
     if(j===res.length) {
       res.push(arr[i]);
     }
   }
  return res;
}
var result = unique(arr2);
//indexOf去重
function unique(origin){
    var result = [];
    for(var i = 0; i< origin.length; i++) {
        var item = origin[i];
        if(result.indexOf(item) === -1) {
            result.push(item);
        }
    }
    return result;
}
//利用Object的key value属性
function unique(origin) {
    var result = [];
    var hashTable = {};
    for(var i = 0; i< origin.length; i++) {
        // 如果键对应的值，为真，意味着对象的键中已经有重复的键了。
        if(!hashTable[origin[i].id]) {
            // 将元素作为对象的键，默认键对应的值为 true, 
            hashTable[origin[i].id] = true;
            // 如果对象中没有这个键，则将这个元素放入结果数组中去。
            result.push(origin[i]);
        }
    }
    return result;
}
// 使用ES6方法
function unique(origin) {
    return Array.from(new Set(origin));
}

- javasript实现深度复制的几种方法

// 定义一个深拷贝函数  接收目标target参数
function deepClone(target) {
    // 定义一个变量
    let result;
    // 如果当前需要深拷贝的是一个对象的话
    if (typeof target === 'object') {
    // 如果是一个数组的话
        if (Array.isArray(target)) {
            result = []; // 将result赋值为一个数组，并且执行遍历
            for (let i in target) {
                // 递归克隆数组中的每一项
                result.push(deepClone(target[i]))
            }
         // 判断如果当前的值是null的话；直接赋值为null
        } else if(target===null) {
            result = null;
         // 判断如果当前的值是一个RegExp对象的话，直接赋值    
        } else if(target.constructor===RegExp){
            result = target;
        }else {
         // 否则是普通对象，直接for in循环，递归赋值对象的所有值
            result = {};
            for (let i in target) {
                result[i] = deepClone(target[i]);
            }
        }
     // 如果不是对象的话，就是基本数据类型，那么直接赋值
    } else {
        result = target;
    }
     // 返回最终结果
    return result;
}
//终极方案
 function copyObject(orig) {
    var copy = Object.create(Object.getPrototypeOf(orig));
    copyOwnPropertiesFrom(copy, orig);
    return copy;
  }


  function copyOwnPropertiesFrom(target, source) {
    Object
    .getOwnPropertyNames(source)
    .forEach(function (propKey) {
      var desc = Object.getOwnPropertyDescriptor(source, propKey);
      Object.defineProperty(target, propKey, desc);
    });
    return target;
  }