Secuencia de Leetcode-Fibonacci (js)

Entendiendo la secuencia de Fibonacci

El n-ésimo número se obtiene sumando los dos primeros de la secuencia: f (n) = f (n-1) + f (n -2), usar código para implementar la secuencia de Fibonacci no es más que investigar la escritura recursiva Sin embargo, usar la recursividad sola no es factible en requisitos estrictos de complejidad de tiempo y complejidad de espacio, porque ha realizado innumerables cálculos inútiles.

1, 1, 2, 3, 5, 8, 13,…

Implementación ordinaria (recursiva)

Al calcular de esta manera, habrá muchos cálculos repetidos, y el número de capas recursivas será cada vez más profundo, y es fácil romper la pila de forma recursiva.

const fib = n => n <= 1 ? n :fib(n-1)+fib(n-2)
console.log(fib(5))

Reducir la complejidad del tiempo (cierre + recursividad)

Al agregar una capa de caché, se utiliza para almacenar los valores que se han calculado antes. Cuando se necesita calcular un nuevo valor, primero se busca en la caché, y los resultados de la caché se devolverán directamente, y el cálculo continuar si se pierde. Pero el uso de matrices aumenta la complejidad del espacio.

const fib3 = function (n) {
    
    
  n <= 1 && n
  const cache = []
  cache[0] = 1
  cache[1] = 1
  function memoize(num) {
    
    
      if (cache[num] !== undefined) {
    
    
          return cache[num]
      }
      cache[num] = memoize(num - 1) + memoize(num - 2)
      // console.log(cache[num])
      return cache[num]
  }
  const result = memoize(n-1)
  return result
}
console.log(fib3(4))

Sin embargo, hay un problema con esta implementación. Si no calcula la secuencia de Fibonacci en orden, aumentará el consumo adicional. Por ejemplo, calcule directamente fib (1000). En este momento, los otros elementos de la matriz en el medio serán inicializado a indefinido. Esto será pequeño. Algún tiempo, pero después de que se completa el cálculo, se completa la secuencia de Fibonacci entre 1-1000.
Una solución en la red de referencia es reemplazar la matriz con objetos para almacenar en caché, de modo que el tiempo de llenado indefinido sea menor.

// 闭包 + 缓存对象
const fibonacci = (function () {
    
    
  const f = {
    
    }
  return function(n) {
    
    
    if(n === 0 || n === 1) {
    
    
      return n
    }
    if(f[n-2] === undefined) {
    
    
      f[n-2] = fibonacci(n-2)
    }
    if(f[n-1] === undefined) {
    
    
      f[n-1] = fibonacci(n-1)
    }
    return f[n] = f[n-1] + f[n-2]
  }
})()

Para cambiar la forma de escribir de adelante hacia atrás ::: A partir del recuento anterior paso a paso, calcule paso a paso y calcule hasta n

const fib =function (n){
    
    
  n <= 1 && n
  const cache = []
  cache[0] = 1
  cache[1] = 1
  for (let i= 2; i<=n; i++ ) {
    
    
    cache[i] = cache[i-1] +cache[i-2]
  }
  return cache[n-1]
}
console.log(fib(5))

Reducir la complejidad del espacio

No utilice y matrices, reduzca la dimensión del espacio de adelante hacia atrás

const fib = n =>{
    
    
    n <= 1 && n
    let prev2 = 0
    let prev1 = 1
    let result = 0
    for (let i = 2;i<=n;i++) {
    
    
      result =prev2+prev1
      prev2 = prev1
      prev1 = result
    }
    return result
}