算法与数据结构基础知识（个人文档）

• 排列组合公式

  
  image
  image

• 数据结构图

  
  

• 深度遍历节点（Depth First Search）

function searchByDepth(root) {
    // doSomething(root)
    var children = node.children
    for (var i = 0; i < children.length; i++) {
      arguments.callee(children[i])
    }
  }

• 广度遍历节点 （Breadth First Search）

function searchByBreadth(root) {
    // 维护一个先进先出的队列
    var queue = [root]
    while (queue.length) {
      var node = queue.shift()
      // doSomething(root)
      queue.push(...node.children)
    }
  }

• 随机数组——洗牌算法

function shuffle(arr) {
    let i = arr.length;
    while (i) {
      let j = Math.floor(Math.random() * i--);  // 这个分号很重要，原理同自执行函数
      [arr[j], arr[i]] = [arr[i], arr[j]]
    }
}

• 数组中3个数乘积最大

// MAX1 * MAX2 * MAX3 || MIN1 * MIN2 * MAX1  这个公式最重要

function maxProduct (arr) {
  arr.sort((a, b) => {
    return a - b > 0
  })

  let len = arr.length
  let res1 = arr[len - 1] * arr[len - 2] * arr[len - 3]
  let res2 = arr[0] * arr[1] * arr[len - 1]

  return Math.max(res1, res2)
}

• 寻找连续数组中的缺失数

// 高斯定理求理论之和，与数组真实之和作差
function findMissingNumber(arr) {
  let len = arr.length + 1
  let min = arr[0]
  let max = arr[0]
  let total = 0

total = arr.reduce( (prev, next, a, c) => {
  max = next > max ? next : max
  min = next < min ? next : min
  return prev + next
})

  return (min + max) * len / 2 - total
}

• 随机数生成算法——线性同余法

// 绝对的随机是不存在的（据说量子力学除外），代码生成的随机都是“伪随机”
var random = (function () {    
  // 种子越随机，结果越~
  // 此处用系统时间作为种子，也可以用主板温度，显卡噪音~你开心就好
  var seed = new Date().getTime()

  // 9301 49297 233280是线性同余法常用的一组参数
  // (X % M) / M 保证了随机数介于[0,1)区间
  function rd (seed) {
    seed = ( seed * 9301 + 49297 ) % 233280
    return seed / 233280
  }

  return function (num) {
    return rd(seed) * (num || 1)
  }

})()

• Fibonacci数列

// 数学归纳法
function fibonacci(n) {
  if (n < 2) {
    return n
  }
  return fibonacci(n - 1) + fibonacci(n - 2)
}

// 求和  前n项和等于第n+2项减1
function sum_fibonacci (n) {
  return fibonacci(n + 2) - 1
}

// 构造斐波拉契数列
function new_fibonacci(n) {
  const arr = []
  if (n === 1) {
    arr.push(1)
  } else if (n > 0) {
    arr.push(1, 1)
    while (n - 2) {
      const len = arr.length
      arr.push(arr[len - 2] + arr[len-1])
      n--
    }
  }
  return arr
}