{"id":21125232,"url":"https://github.com/bchavs12/js_datastructure","last_synced_at":"2026-04-20T04:03:19.568Z","repository":{"id":256211949,"uuid":"854241940","full_name":"bchavs12/JS_dataStructure","owner":"bchavs12","description":"Learning about Data structures","archived":false,"fork":false,"pushed_at":"2024-09-12T17:24:44.000Z","size":5,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-10-14T13:08:32.571Z","etag":null,"topics":["data-structures","java"],"latest_commit_sha":null,"homepage":"","language":"JavaScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/bchavs12.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-09-08T18:41:58.000Z","updated_at":"2024-10-27T16:38:22.000Z","dependencies_parsed_at":"2024-09-09T16:42:58.386Z","dependency_job_id":"1d44a217-c040-403e-b2e7-7d9582a46e4b","html_url":"https://github.com/bchavs12/JS_dataStructure","commit_stats":null,"previous_names":["bchavs12/jsdatastructure","bchavs12/js_datastructure"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/bchavs12/JS_dataStructure","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/bchavs12%2FJS_dataStructure","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/bchavs12%2FJS_dataStructure/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/bchavs12%2FJS_dataStructure/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/bchavs12%2FJS_dataStructure/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/bchavs12","download_url":"https://codeload.github.com/bchavs12/JS_dataStructure/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/bchavs12%2FJS_dataStructure/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":279018700,"owners_count":26086604,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-10-14T02:00:06.444Z","response_time":60,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["data-structures","java"],"created_at":"2024-11-20T04:22:28.897Z","updated_at":"2025-10-14T13:08:40.636Z","avatar_url":"https://github.com/bchavs12.png","language":"JavaScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"## Resumo das Diferenças entre Stack \u0026 Queue\n\n| **Características** | **Stack (Pilha)**             | **Queue (Fila)**              |\n| ------------------- | ----------------------------- | ----------------------------- |\n| **Princípio**       | LIFO (Last In, First Out)     | FIFO (First In, First Out)    |\n| **Inserção**        | `push()` no topo              | `enqueue()` no final          |\n| **Remoção**         | `pop()` do topo               | `dequeue()` do início         |\n| **Uso comum**       | Funções recursivas, undo/redo | Filas de atendimento, buffers |\n| **Exemplo físico**  | Pilha de pratos               | Fila de pessoas               |\n\n# Diversas Formas de Calcular Fibonacci\n\nExistem várias maneiras de calcular a sequência de Fibonacci em JavaScript. Aqui está uma explicação das diferentes abordagens, junto com suas vantagens, desvantagens e eficiência.\n\n## 1. Método Iterativo\n\n```javascript\nfunction fibonacciIterativo(n) {\n  const fibonacci = [0, 1] // Inicializa os dois primeiros valores\n\n  for (let i = 2; i \u003c= n; i++) {\n    fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2]\n  }\n\n  return fibonacci[n]\n}\n\nconsole.log(fibonacciIterativo(10)) // Saída: 55\n```\n\n### Explicação\n\nEste método usa um loop para calcular a sequência de Fibonacci de forma direta. Ele inicia com os dois primeiros números e vai somando os dois últimos números da sequência até atingir o valor desejado.\n\n### Vantagens\n\n- Simples de entender e implementar.\n- Tempo de execução O(n), ou seja, o tempo necessário cresce linearmente conforme o valor de `n`.\n- Armazena todos os números Fibonacci até `n` se necessário.\n\n### Desvantagens\n\n- Utiliza um espaço extra proporcional a `n` para armazenar os valores da sequência.\n\n### Quando Usar\n\nPara cálculos de Fibonacci em pequenos a grandes intervalos, quando a simplicidade e a eficiência em tempo são importantes.\n\n---\n\n## 2. Método Recursivo Simples\n\n```javascript\nfunction fibonacciRecursivo(n) {\n  if (n \u003c= 1) {\n    return n\n  }\n  return fibonacciRecursivo(n - 1) + fibonacciRecursivo(n - 2)\n}\n\nconsole.log(fibonacciRecursivo(10)) // Saída: 55\n```\n\n### Explicação\n\nEsta abordagem segue diretamente a definição matemática da sequência de Fibonacci, onde cada número é a soma dos dois anteriores. Isso é feito recursivamente.\n\n### Vantagens\n\n- Código muito simples e direto.\n- Ideal para entender o conceito de recursão.\n\n### Desvantagens\n\n- Muito ineficiente para valores grandes de `n`, com tempo de execução O(2^n).\n- Recalcula os mesmos valores várias vezes, resultando em uma explosão de chamadas recursivas.\n\n### Quando Usar\n\nPrincipalmente para fins educacionais ou para valores pequenos de `n`, pois não é eficiente para cálculos maiores.\n\n---\n\n## 3. Método Recursivo com Memoização\n\n```javascript\nfunction fibonacciMemoizado(n, memo = {}) {\n  if (n in memo) {\n    return memo[n]\n  }\n  if (n \u003c= 1) {\n    return n\n  }\n  memo[n] = fibonacciMemoizado(n - 1, memo) + fibonacciMemoizado(n - 2, memo)\n  return memo[n]\n}\n\nconsole.log(fibonacciMemoizado(10)) // Saída: 55\n```\n\n### Explicação\n\nMemoização é uma técnica que armazena os resultados das chamadas anteriores, evitando a duplicação de cálculos. Com isso, a recursão se torna muito mais eficiente.\n\n### Vantagens\n\n- Tempo de execução reduzido para O(n), melhorando drasticamente a performance em relação à recursão simples.\n- Combina a simplicidade da recursão com uma maior eficiência.\n\n### Desvantagens\n\n- Ainda requer espaço extra proporcional a `n` para armazenar os resultados calculados previamente.\n\n### Quando Usar\n\nQuando você precisa da simplicidade da recursão, mas com eficiência melhorada. Ideal para problemas grandes que exigem cálculo recursivo.\n\n---\n\n## 4. Fórmula de Binet\n\n```javascript\nfunction fibonacciBinet(n) {\n  const sqrt5 = Math.sqrt(5)\n  const phi = (1 + sqrt5) / 2\n  const psi = (1 - sqrt5) / 2\n\n  return Math.round((Math.pow(phi, n) - Math.pow(psi, n)) / sqrt5)\n}\n\nconsole.log(fibonacciBinet(10)) // Saída: 55\n```\n\n### Explicação\n\nA fórmula de Binet usa álgebra para calcular diretamente o número de Fibonacci na posição `n` sem precisar iterar ou usar recursão. A fórmula envolve números irracionais, como a razão áurea (phi).\n\n### Vantagens\n\n- Tempo de execução O(1), pois calcula o valor diretamente usando uma fórmula matemática.\n- Muito eficiente para valores pequenos e médios de `n`.\n\n### Desvantagens\n\n- Pode ser impreciso para números grandes devido às limitações de precisão de ponto flutuante.\n- Não é tão simples de entender como as outras abordagens.\n\n### Quando Usar\n\nQuando você quer um cálculo rápido de Fibonacci, especialmente para valores não muito grandes, e sem necessidade de armazenar a sequência inteira.\n\n---\n\n## 5. Programação Dinâmica (Espaço Otimizado)\n\n```javascript\nfunction fibonacciDinamico(n) {\n  if (n \u003c= 1) return n\n\n  let a = 0,\n    b = 1,\n    c\n\n  for (let i = 2; i \u003c= n; i++) {\n    c = a + b\n    a = b\n    b = c\n  }\n\n  return b\n}\n\nconsole.log(fibonacciDinamico(10)) // Saída: 55\n```\n\n### Explicação\n\nA programação dinâmica armazena os resultados intermediários e reutiliza-os, mas, em vez de manter todos os valores da sequência, só armazena os dois últimos números. Isso reduz o uso de memória.\n\n### Vantagens\n\n- Tempo de execução O(n) com espaço O(1), o que significa que utiliza uma quantidade constante de memória, independentemente do valor de `n`.\n- Extremamente eficiente tanto em termos de tempo quanto de espaço.\n\n### Desvantagens\n\n- Não armazena todos os valores da sequência, apenas os dois últimos.\n\n### Quando Usar\n\nQuando você quer uma solução eficiente tanto em termos de tempo quanto de espaço, especialmente para valores grandes de `n`. Essa é geralmente a abordagem mais eficiente para a maioria dos casos.\n\n---\n\n## Comparação de Eficiência\n\n| Método                                  | Tempo de Execução | Espaço Utilizado |\n| --------------------------------------- | ----------------- | ---------------- |\n| Iterativo                               | O(n)              | O(n)             |\n| Recursivo Simples                       | O(2^n)            | O(n)             |\n| Recursivo com Memoização                | O(n)              | O(n)             |\n| Fórmula de Binet                        | O(1)              | O(1)             |\n| Programação Dinâmica (Espaço Otimizado) | O(n)              | O(1)             |\n\n## Conclusão\n\nA abordagem mais eficiente para calcular a sequência de Fibonacci, especialmente para valores grandes de `n`, é a **Programação Dinâmica com Espaço Otimizado**. Ela oferece um excelente equilíbrio entre tempo de execução e uso de memória, com complexidade O(n) para tempo e O(1) para espaço.\n\nOutras abordagens, como a recursão simples, são interessantes para fins educacionais, mas devem ser evitadas em contextos de produção devido à sua ineficiência. Para cálculos rápidos sem precisar de armazenamento, a Fórmula de Binet pode ser uma boa alternativa, embora tenha limitações de precisão em grandes valores.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbchavs12%2Fjs_datastructure","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fbchavs12%2Fjs_datastructure","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbchavs12%2Fjs_datastructure/lists"}