Javascript 算法篇（二）

对象（数组）深拷贝

解释 ：当需要复制一个对象的时候我们不能采用 var obj1 = obj 的方式。

// 举例 有一个对象 obj 需要复制它
var obj = {a:1}
// 如果直接采用赋值的方法就会有问题
var obj1 = obj // 这时 obj1 和 obj 的引用地址相同
// 修改obj1的 a元素 会导致 obj 的 a元素 也发生改变
obj1.a = 2
console.log(obj)  // {a:2}
console.log(obj1) // {a:2}

就要采用深拷贝的方式来复制

var deepCopy = function (obj) {
  // 根据参数类型 生成对应的类型变量 
  var result = Array.isArray(obj) ? [] : {};
  for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
      // 子项是对象或者数组的情况
      if (typeof obj[key] === 'object' && obj[key]!==null) {
        result[key] = deepCopy(obj[key]);   // 进行递归
      } else {
        result[key] = obj[key];
      }
    }
  }
  return result;
}

不借助临时变量，进行两个整数的交换
解释 ：写一个函数，给定 a = 2, b = 4 返回 a = 4, b =2，要求函数内不使用其他变量

var a = 2
var b = 4
var swap = function(a , b) {  
  b = b - a;
  a = a + b; // a = a + ( b - a) => a = b
  b = a - b; // b = (a + b) - b  => b = a
  return {a,b};
}
var {a,b} = swap(a,b) // 解构赋值 es6
console.log(a) // 4
console.log(b) // 2

随机生成指定长度或未知长度的字符串
解释：写一个函数，返回一个随机字母字符串，可指定或者不指定长度

/**
 * 产生随机整数，包含下限值，包括上限值
 * @param {Number} lower 下限
 * @param {Number} upper 上限
 * @return {Number} 返回在下限到上限之间的一个随机整数
 */
var randomNum = function (lower, upper) {
    return Math.floor(Math.random() * (upper - lower+1)) + lower;
} 
// 生成随机字符串
var randomString = function(n) {
  // 校验非空 
  if (n === void(0) || n ===0 || n === null) {
    n = randomNum(1,20) // 空的情况就随机生成1到20的数作为长度
  }
  var strTemp = 'abcdefghijklmnopqrstuvwxyz'
  var resStr = ''
  for(let i = 0; i < n; i++){
    resStr += strTemp.charAt(randomNum(0,25))
  } 
  return resStr
}
console.log(randomString(8)) // 给定长度: sphzknnh
console.log(randomString())  // 随机长度: cbjstaluuumdsdha

冒泡排序法

var arrays = [81, 23, 46, 11, 56, 69, 57, 78, 99, 21, 23];
for (var i = 0; i < arrays.length - 1; i++) {
  for (var j = 0; j < arrays.length - 1 - i; j++) {
    if (arrays[j] > arrays[j + 1]) {
      var t = arrays[j + 1];
      arrays[j + 1] = arrays[j];
      arrays[j] = t;
    }
  }
}

选择排序法

var arrays = [81, 23, 46, 11, 56, 69, 57, 78, 99, 21, 23];
//选择排序法
for (var i = 0; i < arrays.length - 1; i++) {
  for (var j = i + 1; j < arrays.length; j++) {
    if (arrays[i] > arrays[j]) {
      var t = arrays[i];
      arrays[i] = arrays[j];
      arrays[j] = t;
    }
  }
}
console.log(arrays);

函数柯里化

// 函数柯里化：利用返回函数的方式，将多个参数进行分解，单一参数。

// 普通函数
function add(x, y) {
  return x + y;
}

// 函数柯里化
function add(x) {
  return function(y) {
    return x + y;
  };
}

console.log(add(1)(2))
// 函数柯里化封装
function add(x, y) {
  return x + y;
}

function curried(fn, ...arg1) {
  return function(...arg2) {
    return fn(...arg1, ...arg2);
  };
}

var increment = curried(add, 1);
console.log(increment(2));

// 函数柯里化更适合函数式编程方法

new 实现原理

function myFun() {

}

var f = new myFun();

console.log(f instanceof myFun);
console.log(_instanceof(f, myFun));
var s = "str"
console.log(_instanceof(s, String));
console.log(s instanceof String);

function _instanceof(left, right) {
  var left = left.__proto__;
  var prototype = right.prototype;
  while (true) {
    if (left == null) {
      return false;
    }
    if (left == prototype) {
      return true;
    }
    left = left.__proto__;
  }
}

数组去重

var arr = [2,5,3,6,2,4,5,8,3]
var obj = {}
for (var i = 0; i < arr.length; i++) {
    if(!obj[arr[i]]){
      obj[arr[i]] = 1
    }
}
console.log(obj)

斐波那契数列

function fibonacci(n) {
  return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
}
console.log(fibonacci(5)) // 1 1 2 3 5

JavaScript深拷贝

var obj1 = {
  o: {
    name: "hello"
  },
  arr: [1, 2, {
    pass: 333
  }],
  str: "world"
};

function isType(target) {
  return Object.prototype.toString.call(target).slice(8, -1);
}

function deepCopy(target) {
  var type = isType(target);
  var reslut;
  if (type === "Array") {
    reslut = [];
  } else if (type === "Object") {
    reslut = {};
  } else {
    return target
  }
  for (var key in target) {
    var value = target[key];
    if (isType(value) === "Object" || isType(value) === "Array") {
      reslut[key] = deepCopy(value);
    } else {
      reslut[key] = value;
    }
  }
  return reslut;
}

var obj2 = deepCopy(obj1);

obj2.o.name = "hello x";
obj2.arr[0] = 11;
obj2.arr.push(4);
obj2.arr[2].pass = 555;
obj2.str = "world x";

console.log("new obj1", obj1);
console.log("new obj2", obj2);

统计出现组多的元素

var arr = ["1", "2", "345", "3", "21", "345","4", "23", "88", "25", "2", "3", "99"];
var maxStack = {};
for (var i = 0; i < arr.length; i++) {
  var item = arr[i];
  if (!maxStack[item]) {
    maxStack[item] = 1;
  } else {
    maxStack[item] = maxStack[item] + 1;
  }
}
console.log(maxStack);