<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jonathan Juliani on Medium]]></title>
        <description><![CDATA[Stories by Jonathan Juliani on Medium]]></description>
        <link>https://medium.com/@jonathanjuliani?source=rss-d03446c44cae------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*yW-bP36Z2dWrREXWvTt23g.png</url>
            <title>Stories by Jonathan Juliani on Medium</title>
            <link>https://medium.com/@jonathanjuliani?source=rss-d03446c44cae------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 18:11:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jonathanjuliani/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Skilldeck: skills de IA que leem o repo antes da stack | jonathanjuliani.dev]]></title>
            <link>https://medium.com/@jonathanjuliani/skilldeck-skills-de-ia-que-leem-o-repo-antes-da-stack-jonathanjuliani-dev-2e1a8e5c48df?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e1a8e5c48df</guid>
            <category><![CDATA[agent-skills]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 00:00:09 GMT</pubDate>
            <atom:updated>2026-10-29T15:41:01.512Z</atom:updated>
            <content:encoded><![CDATA[<p>Você instala skills de IA e, na primeira tarefa, o agente troca o Jest do repo por Vitest, ou o npm por pnpm, ou empurra uma biblioteca que ninguém no time pediu.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9S_TceYKWedUh_Y2" /></figure><blockquote><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/skilldeck-skills-agentes-ia"><em>jonathanjuliani.dev</em></a><em> on October 27, 2026.<br>English version available at: </em><a href="https://jonathanjuliani.dev/en-US/blog/skilldeck-agent-skills-javascript"><em>jonathanjuliani.dev — skilldeck</em></a></blockquote><p>A skill parou de ler o projeto e começou a decidir por ele.</p><p>Foi isso que me fez construir o <strong>skilldeck</strong>: 36 skills (no momento em que eu escrevo isso) para JavaScript e TypeScript que primeiro leem o repositório e só depois recomendam alguma coisa. Este post é uma retrospectiva do conceito, da versão 0.1.0 à 1.0.2, com as três decisões principais que importaram e o que ainda está torto.</p><p><strong>O que você vai aprender:</strong></p><ul><li>Por que eu construí outro pacote de skills</li><li>Quais skills moldaram ele</li><li>Se ele substitui outros pacotes, e por que usar ou não</li><li>Stacks que as mesmas skills ainda atendem, de Jest e npm a Express, NestJS e Redux Toolkit</li><li>Por que o peso do pacote é engineering, e onde um companion como o caveman entra</li><li>A cadeia de precedência: um standard de projeto ou de empresa fica acima da skill</li><li>Por que existe um marketplace só, e não vários para cada “categoria”/”assunto”</li><li>O que o Cursor recusa (symlink) e como contornei [trabalho em andamento para corrigir isso]</li><li>O que eu faria diferente, e o que eu ainda não sei</li><li>O que vem agora no skilldeck</li></ul><h3>Por que mais um pacote de skills de IA?</h3><p>Vários pacotes que eu testei nascem em volta de uma stack, ou de um harness só. Isso é uma escolha de verdade, e alguns deles são o motivo dessas skills existirem. O skilldeck faz a outra escolha: o mesmo conjunto de skills, padrões, standards e helpers, em cima do que o projeto já usa.</p><p>Eu tentei desenhar ele como um companion que não interfere na stack do projeto, e sim ajuda o projeto a seguir, e claro, se precisar, oferece alternativa e melhoria.</p><p>Ele fica quase quieto sobre vendor. Tenta definir e se apoiar em <strong>preferências e padrões da comunidade</strong> com base na minha experiência, em pacotes novos e ferramentas da comunidade que estão surgindo no ecossistema, e também em qualquer padrão/design do projeto ou standard da empresa que já esteja definido ou embutido no projeto, e isso fica acima da skill quando existe. O lema do repositório resume:</p><blockquote>Detect before you decide. <br>Recommend before you impose. <br>Ask before you assume. <br>Prove before you claim.</blockquote><p>As mesmas skills rodam no Claude Code, no Cursor, no Codex, no Gemini, e possivelmente em outros que usam o setup de .agents. Confesso que ainda não consegui testar todos (e agradeço a ajuda nisso). Também rodam quando o repo já está em Jest, npm, Express, NestJS, Redux Toolkit, Cypress, Prisma ou CSS Modules (aparecem o tempo todo, e o trabalho da skill é conviver com elas). Um serviço legado com npm e Jest, um monorepo com pnpm e Vitest, ou um app Expo recém-criado recebem a mesma ajuda.</p><p>Algumas skills moldaram e inspiraram pedaços deste pacote. Ainda são as que eu abro quando quero aquele pedaço, ou algo específico, bem a fundo:</p><ul><li><a href="https://github.com/obra/superpowers">obra/superpowers</a> está por trás de verify-before-done.</li><li><a href="https://github.com/mattpocock/skills">mattpocock/skills</a> é a entrevista completa. align-first é a versão leve dela.</li><li><a href="https://github.com/addyosmani/agent-skills">addyosmani/agent-skills</a> é o pacote mais largo. security-hardening, observability e ship-flow vão para lá quando a tarefa pede mais fundo.</li><li><a href="https://github.com/educlopez/ui-craft">educlopez/ui-craft</a> está por trás de design-review e design-inspiration.</li></ul><p>O skilldeck fica com esse conjunto. Esses pacotes continuam separados, e a stack preferida também. O objetivo é as mesmas skills, padrões, standards e helpers, na ferramenta que o projeto ou a empresa já escolheu.</p><p>São 36 skills em quatro grupos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*CH4zIQ83teaxp255vtYbpA.png" /></figure><p>22 das 36 são engineering. Design e process fazem parte do pacote. O peso é engineering, e são essas skills que mais escrevem, então um companion que corta token de saída melhora a sessão inteira. O <a href="https://github.com/JuliusBrussee/caveman">caveman</a> faz isso. Ele fica ao lado do skilldeck (não é uma das 36), e o trabalho de engineering continua, com menos prosa em volta.</p><p>Cada grupo separado. Foundation detecta, configura e escreve o arquivo de instruções.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*InzeEFObgA-qUwWKI0W8lA.png" /></figure><p>Engineering é o grupo pesado, desenhado nos quatro degraus do mapa do pacote.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xLWWq2aEs3XcgfIJGbDl1Q.png" /></figure><p>Design decide a superfície antes de qualquer build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5n--7F_hfriRPT4BZDiHng.png" /></figure><p>Process fica em volta do trabalho: alinhar, investigar, planejar, desenhar, olhar para trás.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rLH3Cp6hIyE2WtMUsFWIjw.png" /></figure><h3>Linha do tempo: do 0.1.0 ao 1.0.2</h3><p>Em duas semanas saíram oito versões. Quase todas as 0.1.x foram conserto de instalação e de nome, não de conteúdo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*B34Je9Wj5Iye-4E2gXJ4hA.png" /></figure><p>O 1.0.0 saiu no mesmo dia do 0.1.4. As três decisões abaixo são o que sustenta a coleção desde então.</p><h3>Decisão 1: a cadeia de precedência das skills de IA</h3><p>Skill que troca a stack está decidindo pelo repo. Então a primeira decisão foi <strong>quem manda em quem</strong>. A cadeia para na primeira camada que responde:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q78bVoslnmyJOxaFH8tT4A.png" /></figure><p>Pensa num dev que acabou de entrar no time. Ele não chega reescrevendo tudo com a stack que ele curte: primeiro olha como o código já é feito, depois o guia interno da empresa, e só usa o gosto pessoal quando as duas coisas não dizem nada. A cadeia é isso, só que para o agente.</p><p>Na prática:</p><ul><li><strong>Projeto</strong>: o que o agente detecta no repo (gerenciador de pacotes, test runner, estrutura) vence sempre.</li><li><strong>Empresa</strong>: padrões do time entram depois do que o código já mostra.</li><li><strong>Pessoal</strong>: só desempata, não manda.</li><li><strong>Comunidade</strong>: só vale em projeto novo (greenfield), e o agente <strong>oferece com um motivo e espera confirmação</strong>. Nada de aplicar no automático.</li></ul><p>Um repo em Jest e npm, ou um standard da empresa que diz a mesma coisa, é a resposta. O snapshot da comunidade pode preferir Vitest e pnpm. A skill não troca.</p><p>Então, por que não só um AGENTS.md bem escrito?</p><p>Porque a skill só chega no modelo quando algo vai procurar por ela, e um arquivo lido a cada turno chega sempre. Por isso o setup-skills pode escrever, se você quiser, um bloco de verificação e um bloco de roteamento no AGENTS.md ou CLAUDE.md. A skill ensina; o arquivo garante que o agente lembre.</p><p>Uma objeção que eu mesmo fiz: “detectar custa tempo e token”. Custa, sim. Mas errar a stack custa mais, porque você só descobre no code review.</p><h3>Decisão 2: um marketplace só</h3><p>Marketplace aqui é o catálogo de onde o agente instala plugins. O skilldeck tem um. Claude Code, Cursor, Codex, Gemini e Copilot instalam todos desse mesmo catálogo, e o id de instalação é skilldeck@skilldeck.</p><p>Um segundo marketplace é uma segunda cópia das mesmas skills. O agente não sabe qual cópia está atual, então pede para escolher uma. Cada ferramenta tem o próprio manifesto, e todo manifesto descreve esse plugin só. O validador mantém eles alinhados, para não virarem dois pacotes.</p><p>Outro detalhe que me custou um tempo: instalar o plugin <strong>e</strong> rodar npx skills carrega cada skill em dobro, e o agente te pergunta &quot;Pick one&quot;. Ele não sabe qual das duas cópias é a certa, e com razão, né? Hoje a documentação diz para escolher um caminho só.</p><h3>Decisão 3: sobre o Cursor e os symlinks</h3><p>Aqui eu apanhei. Eu abro o Cursor, importo do GitHub e… nenhuma skill. Zero. Aí eu vou olhar a estrutura e o problema está lá: o pacote era um symlink saindo de plugins/skilldeck.</p><p>Symlink é um atalho de pasta, tipo o atalho da área de trabalho que aponta para o arquivo de verdade em outro lugar. O Claude segue o atalho. O Cursor não segue, simplesmente ignora.</p><p>A solução foi inverter: os arquivos reais agora ficam em plugins/skilldeck/, e a pasta skills/ na raiz é que virou o atalho para eles, para o npx skills continuar funcionando. Dava para apontar o source do Claude direto para a raiz (./), que é válido para ele, mas o Cursor rejeita esse formato. Por isso os arquivos ficaram mesmo dentro de plugins/skilldeck/.</p><p>Dois outros tropeços do mesmo tipo, os “pequenininhos” que ninguém avisa:</p><ul><li>Descrição de skill com dois-pontos sem aspas vira um mapa YAML em vez de texto. O validate.py agora checa isso.</li><li>Skills que chamam umas às outras podem formar ciclo. O validate.py também detecta ciclos no grafo de chamadas.</li></ul><p>O formato das descrições ficou fixo: o que a skill faz, “Use when” e “Not for”. Isso ajuda o agente a escolher a skill certa em vez de disparar duas.</p><h3>O que eu faria diferente</h3><p>Algumas coisas que eu faria diferente:</p><ul><li>Eu testaria a instalação em cada agente alvo antes de publicar a primeira versão: as releases iniciais depois do baseline foram quase só conserto de instalação e de nome, e um teste simples de instalação teria pego isso. Os comandos de aceitação do Codex e do Gemini eu pulei na fase 1, porque nenhum dos dois estava no PATH nem instalado, e isso ainda é dívida.</li><li>Eu checaria, e provavelmente vou checar e adaptar, as skills para ficarem mais compatíveis com outras linguagens e frameworks, e não só o ecossistema JavaScript/TypeScript.</li><li>Eu focaria um pouco mais em outras áreas maiores, tipo system design, security, observability e process, em vez de focar mais em padrão/design e standard de código. Mas olha o que vem logo abaixo, é exatamente nisso que eu estou trabalhando.</li></ul><h3>O que eu ainda não sei</h3><ul><li>Não sei se uma cadeia de precedência com quatro níveis é simples o bastante para outras pessoas, ou se só faz sentido pra mim.</li><li>Também não testei o skilldeck fora do ecossistema JS/TS, que é algo que eu quero fazer e vou fazer em breve.</li><li>Não medi se os blocos no AGENTS.md mudam o comportamento do agente em tarefas longas.</li></ul><p>É um trabalho constante, e eu fico feliz de contar com a sua ajuda nisso.</p><h3>O que vem agora no skilldeck</h3><p>A próxima rodada provavelmente inclui algumas das dívidas acima. Ainda não sei quando, mas em breve:</p><ul><li>Rodar os comandos de aceitação no Codex e no Gemini, que ficaram de fora.</li><li>Medir se os blocos no AGENTS.md mudam o comportamento do agente em tarefas longas, em vez de achar que mudam.</li><li>Testar a instalação em outros agentes alvo.</li></ul><p>Junto com isso, conforme eu trabalho em projetos e produtos diferentes, já está rascunhado e eu estou curando e testando alguns companions que vão pegar system design, security, observability e process.</p><p>As skills não vão crescer. As de baixo são companions que só disparam quando a tarefa é sobre aquele assunto e precisa delas:</p><ul><li>api-design ganha idempotência. A chave nomeia uma tentativa, e todo retry dessa tentativa reusa essa chave (chave nova no retry é como a mesma tentativa roda duas vezes). A mesma chave com um body diferente é conflito.</li><li>data-model ganha dinheiro e transações. Um valor é um inteiro na menor unidade, com a moeda, e o servidor recalcula o total. Dois writers não leem uma quantidade e os dois escrevem de volta. Uma chamada para outro sistema fica fora da transação do banco.</li><li>frontend-craft ganha um client resiliente, e regras para um dispositivo desassistido ou compartilhado. Toda request tem timeout. Timeout é um resultado desconhecido, então a tela confere o status em vez de convidar um segundo envio. Uma tela compartilhada reseta quando fica parada, e o texto de recuperação assume que não tem ninguém ali para perguntar.</li><li>testing-strategy ganha caminhos de falha. O teste afirma o que foi gravado, não quantas vezes uma função foi chamada.</li><li>state-management guarda o trabalho em andamento no session storage, com a chave de idempotência, para um reload retomar a mesma tentativa.</li><li>security-hardening nomeia o que um cartão pode deixar para trás: um token, os últimos 4 dígitos, a bandeira e a validade. O número completo e o código de segurança nunca são gravados.</li><li>ts-standards diz a mesma coisa sobre dinheiro, numa linha. design-brief nomeia um dispositivo desassistido ou compartilhado como superfície, e design-review pergunta se um estranho nessa superfície consegue se recuperar sozinho.</li><li>bootstrap-repo pede um readme que um estranho consiga seguir. verify-before-done roda esse readme num ambiente limpo só quando a afirmação é que ele consegue.</li></ul><h3>Próximos passos com skills de IA</h3><p>Quer testar? O repositório está em <a href="https://github.com/jonathanjuliani/skilldeck">github.com/jonathanjuliani/skilldeck</a>, licença MIT, com o guia em docs/install.md.</p><p>Se você mexe com IA em produção, vale ler também <a href="https://jonathanjuliani.dev/pt-BR/blog/codigo-ia-producao-alpine-temporal">o caso do Dockerfile que a IA gerou e quebrou o Temporal</a> e <a href="https://jonathanjuliani.dev/pt-BR/blog/arquiteturas-node-erradas">as 4 arquiteturas Node erradas que eu vejo em todo projeto</a>.</p><h3>TL;DR</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*_ISnM8svlq3u8_AFjI7q6g.png" /></figure><h3>E agora é com você</h3><p>Qual padrão/design do seu repo que a sua IA ignora ou já ignorou alguma vez? e que você já cansou de explicar? Me conta, porque é aí que a próxima skill nasce. Se o seu agente já deu uma zika dessas, manda nos comentários ou na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">newsletter</a>.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/skilldeck-skills-agentes-ia"><em>jonathanjuliani.dev</em></a><em> on October 27, 2026.<br>English version available at: </em><a href="https://jonathanjuliani.dev/en-US/blog/skilldeck-agent-skills-javascript"><em>jonathanjuliani.dev — skilldeck</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e1a8e5c48df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Busca Binária com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-busca-bin%C3%A1ria-com-nodejs-e-javascript-4096aaef25ce?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/4096aaef25ce</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Fri, 14 Jun 2024 00:00:22 GMT</pubDate>
            <atom:updated>2026-06-18T15:31:00.985Z</atom:updated>
            <content:encoded><![CDATA[<p>Buscar 42 num array de 1 milhão de posições um a um é lento. Com array <strong>ordenado</strong>, <strong>busca binária</strong> corta o espaço pela metade a cada passo - O(log n).</p><p><strong>O que você vai aprender:</strong></p><ul><li>Versão iterativa e recursiva</li><li>Por que (lo + hi) &gt;&gt;&gt; 1 no meio</li><li>Retornar índice ou -1</li><li>Generalizar para “primeiro true em sequência monótona”</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript">ordenação (ep. 15)</a> e <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-arrays-with-nodejs-and-javascript">arrays (ep. 2)</a>.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><h3>Busca binária: dividir o array ordenado</h3><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*4BptasOQ9-rUcfk6" /></figure><p>Chegamos ao Post 16-o post final do <strong>Data Structures in a Nutshell</strong>. E a gente tá encerrando com um dos algoritmos mais elegantes da ciência da computação: busca binária.</p><p>Você usou busca binária indiretamente ao longo de toda essa série. BSTs usam a mesma lógica de “vai pra esquerda se menor, pra direita se maior”. Heaps usam intuição similar de dividir e conquistar. Agora vamos ver diretamente num array ordenado.</p><p>A ideia é simplesíssima: dado um array ordenado e um valor alvo, verifica o elemento do meio. Se for o alvo, acabou. Se o alvo for menor, joga fora a metade direita. Se for maior, joga fora a metade esquerda. Repete até achar ou não sobrar nada.</p><p>Busca binária pelo valor 7 no array ordenado do artigo, com lo, hi e mid</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*WhN3vomjlyMrGA0grHK8kg.png" /></figure><p>Cada passo corta o espaço de busca pela metade. Pra um array de 1 bilhão de elementos, são no máximo <strong>30 comparações</strong> pra achar qualquer valor. Compara isso com varrer até 1 bilhão de itens linearmente-é O(log n) vs O(n) e a diferença é enorme.</p><h3>Mão na Massa</h3><h4>Um Pouco Mais de Teoria</h4><p>Busca binária tem um requisito rígido: <strong>o array deve estar ordenado</strong>. Esse é o contrato. Se o array estiver desordenado, a busca binária dá resultados errados silenciosamente-não vai dar erro, vai só perder coisas.</p><p>A outra sutileza é o cálculo do ponto médio. O ingênuo (lo + hi) / 2 pode causar overflow quando lo e hi são inteiros grandes (importa mais em linguagens com inteiros de tamanho fixo como Java ou C, mas é um bom hábito). A versão segura é (lo + hi) &gt;&gt;&gt; 1, que usa um shift à direita sem sinal pra dividir a soma ao meio sem overflow.</p><h4>Agora a Prática</h4><p>Cria um arquivo chamado binary-search.js e cola o código abaixo:</p><pre>// Iterativa — a versão que você vai usar em produção<br>function binarySearch(sorted, target) {<br>  let lo = 0<br>  let hi = sorted.length - 1<br> <br>  while (lo &lt;= hi) {<br>    const mid = (lo + hi) &gt;&gt;&gt; 1<br> <br>    if (sorted[mid] === target) return mid<br>    if (sorted[mid] &lt; target) lo = mid + 1<br>    else hi = mid - 1<br>  }<br> <br>  return -1 // não encontrado<br>}</pre><p>Explicando:</p><ul><li>Começamos com lo no início e hi no fim do array.</li><li>Cada iteração calcula o ponto médio mid.</li><li>Se sorted[mid] é nosso alvo, retorna o índice imediatamente.</li><li>Se o alvo é maior que sorted[mid], ele deve estar na metade direita-move lo pra depois de mid.</li><li>Se o alvo é menor, ele deve estar na metade esquerda-move hi pra antes de mid.</li><li>Se lo ultrapassar hi, esgotamos o espaço de busca-retorna -1.</li></ul><p>Agora vamos adicionar a versão recursiva também, já que é uma pergunta comum em entrevistas e mostra a mesma lógica de um ângulo diferente:</p><pre>// Recursiva — elegante, mas cuidado com arrays muito grandes (profundidade de pilha)<br>function binarySearchRecursive(sorted, target, lo = 0, hi = sorted.length - 1) {<br>  if (lo &gt; hi) return -1<br> <br>  const mid = (lo + hi) &gt;&gt;&gt; 1<br> <br>  if (sorted[mid] === target) return mid<br>  if (sorted[mid] &lt; target) return binarySearchRecursive(sorted, target, mid + 1, hi)<br>  return binarySearchRecursive(sorted, target, lo, mid - 1)<br>}</pre><p>Vamos testar os dois. Depois das funções, adiciona:</p><pre>const sorted = [1, 3, 5, 7, 9, 11, 13, 17, 21, 25]<br> <br>console.log(&#39;Array:&#39;, sorted)<br>console.log()<br> <br>// Iterativa<br>console.log(&#39;binarySearch(sorted, 7)  → índice&#39;, binarySearch(sorted, 7))<br>console.log(&#39;binarySearch(sorted, 1)  → índice&#39;, binarySearch(sorted, 1))<br>console.log(&#39;binarySearch(sorted, 25) → índice&#39;, binarySearch(sorted, 25))<br>console.log(&#39;binarySearch(sorted, 6)  → índice&#39;, binarySearch(sorted, 6))<br>console.log()<br> <br>// Recursiva<br>console.log(&#39;binarySearchRecursive(sorted, 13) → índice&#39;, binarySearchRecursive(sorted, 13))<br>console.log(&#39;binarySearchRecursive(sorted, 99) → índice&#39;, binarySearchRecursive(sorted, 99))</pre><p>Roda:</p><pre>node binary-search.js</pre><p>Resultado esperado:</p><pre>Array: [<br>   1,  3,  5,  7,  9,<br>  11, 13, 17, 21, 25<br>]<br> <br>binarySearch(sorted, 7)  → índice 3<br>binarySearch(sorted, 1)  → índice 0<br>binarySearch(sorted, 25) → índice 9<br>binarySearch(sorted, 6)  → índice -1<br> <br>binarySearchRecursive(sorted, 13) → índice 6<br>binarySearchRecursive(sorted, 99) → índice -1</pre><p>As duas implementações retornam o índice correto pra valores que existem e -1 pra valores que não existem.</p><blockquote><em>Jon, e se tiver valores duplicados no array?</em></blockquote><p>Boa observação. A busca binária padrão acha <em>um</em> índice que bate, mas não necessariamente o primeiro ou o último. Se você precisar da ocorrência mais à esquerda ou mais à direita, continua buscando depois de achar uma correspondência em vez de retornar imediatamente. Isso se chama busca de <strong>lower bound</strong> ou <strong>upper bound</strong> -vale conhecer pra entrevistas.</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Buscas em Índices de Banco de Dados</h4><p>Quando um banco de dados faz uma varredura de índice B-Tree, o lookup em cada nó é essencialmente uma busca binária sobre as chaves ordenadas armazenadas ali. Sem ordenação, índices não funcionariam.</p><p>git bisect é literalmente busca binária aplicada ao histórico de commits. Você diz pro Git &quot;esse commit é bom, esse é ruim&quot; e ele faz checkout do commit do meio pra você testar-cortando o espaço de busca pela metade a cada passo até encontrar o primeiro commit ruim. Elegante demais.</p><h4>Funções de Biblioteca Padrão</h4><p>Muitas linguagens implementam busca binária nas bibliotecas padrão:</p><ul><li>JavaScript: sem busca binária nativa, mas Array.prototype.findIndex com comparador pode ser lento pra arrays grandes ordenados-uma busca binária customizada é muito mais rápida.</li><li>Python: bisect.bisect_left / bisect.bisect_right</li><li>Java: Arrays.binarySearch</li><li>Go: sort.SearchInts</li></ul><h3>Edge cases: array desordenado e off-by-one</h3><p>Busca binária em array <strong>não ordenado</strong> não explode — retorna lixo silencioso. Ordene antes ou use Map.</p><p>Condição de loop: lo &lt;= hi (iterativa). Esquecer mid + 1 / mid - 1 causa loop infinito.</p><h3>TL;DR — Busca binária</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*RVKKYH6CKkIIFwaU7gp1PQ.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Esse foi o fechamento da série:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/a-summary-on-the-most-used-ones">Resumo das estruturas</a></li><li>Fica ligado porque vou trazer mais conteúdos assim depois, sempre voltado a explicar o que dá pra usar, onde vemos, e quando faz sentido.</li><li><strong>Se não viu, veja esse meu outro post sobre Módulos Node:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/understanding-node-require-and-exports">require e exports</a></li></ul><h3>Antes de fechar</h3><p>Fim da série Data Structures in a Nutshell — 16 episódios. Qual post mais te ajudou? Se viu erro em algum código da série, comenta que corrigimos juntos.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on June 14, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4096aaef25ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ordenando Arrays com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/ordenando-arrays-com-nodejs-e-javascript-ceb7133a10eb?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/ceb7133a10eb</guid>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Sat, 01 Jun 2024 00:00:03 GMT</pubDate>
            <atom:updated>2026-06-17T15:31:01.010Z</atom:updated>
            <content:encoded><![CDATA[<p>array.sort() sem comparador ordena como <strong>string</strong> - [10, 2, 1].sort() vira [1, 10, 2]. Entender bubble, merge e quick é o que te salva em entrevista e em debug de performance.</p><p><strong>O que você vai aprender:</strong></p><ul><li>Bubble, merge e quick em código</li><li>Complexidade média e pior caso</li><li>Estabilidade e quando importa</li><li>Usar Array.sort com comparador correto</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-arrays-with-nodejs-and-javascript">arrays (ep. 2)</a>.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><h3>Algoritmos de ordenação: bubble, merge e quick</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bl15XH08rUwbm9kL" /></figure><p>Ordenação é uma das operações mais fundamentais da computação. Você provavelmente usa Array.sort() todo dia sem pensar-mas você sabe o que ele está fazendo de verdade? Sabe por que ordenar um milhão de números é rápido mas um bilhão é muito, muito mais lento? E sabe quando o sort nativo pode te dar resultados errados silenciosamente?</p><p>É disso que trata esse post. A gente vai implementar alguns algoritmos clássicos de ordenação, entender as diferenças de performance e terminar com dicas pra usar o sort nativo do JavaScript corretamente.</p><h4>Um Pouco de Teoria Antes</h4><p>Antes de escrever qualquer código, vamos ver o quadro de Big-O:</p><p>Alguns conceitos-chave:</p><ul><li><strong>Sort estável</strong>: se dois elementos são iguais, eles mantêm a ordem relativa original. Isso importa quando você ordena objetos por uma propriedade e quer que outra propriedade fique na ordem anterior.</li><li><strong>In-place</strong>: o algoritmo ordena dentro do mesmo array sem alocar memória extra. Bubble sort e quick sort são in-place; merge sort precisa de espaço extra.</li></ul><p>Veja como o merge sort divide e depois junta de novo as coisas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*10JLU6ZdT8NXNNxC-pyxHQ.png" /></figure><p>Divide até ter elementos únicos (que estão trivialmente ordenados), depois une os pares de volta-sempre em ordem.</p><h3>Mão na Massa</h3><h4>Agora a Prática</h4><p>Cria um arquivo chamado sort.js e vamos começar com o algoritmo mais simples:</p><p><strong>Bubble Sort</strong></p><pre>function bubbleSort(arr) {<br>  const a = [...arr] // não muta o original<br>  const n = a.length<br>  for (let i = 0; i &lt; n - 1; i++) {<br>    let swapped = false<br>    for (let j = 0; j &lt; n - i - 1; j++) {<br>      if (a[j] &gt; a[j + 1]) {<br>        ;[a[j], a[j + 1]] = [a[j + 1], a[j]]<br>        swapped = true<br>      }<br>    }<br>    if (!swapped) break // já ordenado — melhor caso O(n)<br>  }<br>  return a<br>}</pre><p>O bubble sort funciona trocando repetidamente elementos adjacentes que estão fora de ordem. Depois de cada passagem completa, o maior elemento não ordenado “borbulhou” pra sua posição correta no final. O flag swapped é uma otimização: se nenhuma troca aconteceu numa passagem completa, o array já está ordenado e podemos parar.</p><p><strong>Merge Sort</strong></p><pre>function mergeSort(arr) {<br>  if (arr.length &lt;= 1) return arr<br> <br>  const mid = Math.floor(arr.length / 2)<br>  const left = mergeSort(arr.slice(0, mid))<br>  const right = mergeSort(arr.slice(mid))<br> <br>  return merge(left, right)<br>}<br> <br>function merge(left, right) {<br>  const result = []<br>  let l = 0<br>  let r = 0<br> <br>  while (l &lt; left.length &amp;&amp; r &lt; right.length) {<br>    if (left[l] &lt;= right[r]) {<br>      result.push(left[l++])<br>    } else {<br>      result.push(right[r++])<br>    }<br>  }<br> <br>  return result.concat(left.slice(l)).concat(right.slice(r))<br>}</pre><p>Merge sort é um algoritmo clássico de dividir e conquistar:</p><ol><li><strong>Dividir</strong>: divide o array ao meio recursivamente até cada pedaço ter um elemento.</li><li><strong>Conquistar</strong>: une pares de pedaços ordenados de volta, sempre escolhendo o menor elemento da frente.</li></ol><p>É estável e sempre O(n log n), mas precisa de memória extra proporcional ao tamanho da entrada.</p><p><strong>Sort nativo</strong></p><pre>// Lexicográfico por padrão (NÃO use sem comparador pra números!)<br>[10, 9, 2, 100].sort()           // [10, 100, 2, 9] — ERRADO pra números!<br> <br>// Numérico crescente correto<br>[10, 9, 2, 100].sort((a, b) =&gt; a - b)   // [2, 9, 10, 100]<br> <br>// Numérico decrescente correto<br>[10, 9, 2, 100].sort((a, b) =&gt; b - a)   // [100, 10, 9, 2]<br> <br>// Ordenar objetos por uma propriedade<br>const users = [<br>  { name: &#39;Charlie&#39;, age: 30 },<br>  { name: &#39;Alice&#39;, age: 25 },<br>  { name: &#39;Bob&#39;, age: 28 },<br>]<br>users.sort((a, b) =&gt; a.age - b.age)<br>// [Alice (25), Bob (28), Charlie (30)]</pre><p>Agora vamos fazer um teste completo. Adiciona isso depois das funções:</p><pre>const nums = [38, 27, 43, 3, 9, 82, 10]<br> <br>console.log(&#39;Original:&#39;, nums)<br>console.log(&#39;Bubble sort:&#39;, bubbleSort(nums))<br>console.log(&#39;Merge sort:&#39;, mergeSort(nums))<br>console.log(&#39;Sort nativo (errado — lexicográfico):&#39;, [...nums].sort())<br>console.log(&#39;Sort nativo (correto — numérico):&#39;, [...nums].sort((a, b) =&gt; a - b))</pre><p>Roda:</p><pre>node sort.js</pre><p>Resultado esperado:</p><pre>Original: [<br>  38, 27, 43,  3,<br>   9, 82, 10<br>]<br>Bubble sort: [<br>   3,  9, 10, 27,<br>  38, 43, 82<br>]<br>Merge sort: [<br>   3,  9, 10, 27,<br>  38, 43, 82<br>]<br>Sort nativo (errado — lexicográfico): [<br>  10, 27,  3, 38,<br>  43,  9, 82<br>]<br>Sort nativo (correto — numérico): [<br>   3,  9, 10, 27,<br>  38, 43, 82<br>]</pre><p>As três implementações corretas produzem [3, 9, 10, 27, 38, 43, 82]. E viu o sort nativo &quot;errado&quot;? Esse é o bug clássico- Array.sort converte elementos pra string por padrão, então 10 vem antes de 3 porque &quot;1&quot; &lt; &quot;3&quot; lexicograficamente. Sempre passe um comparador ao ordenar números.</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Pré-processamento Antes de Busca Binária</h4><p>Busca binária (próximo post!) requer um array ordenado. Se você tem um conjunto de dados desordenado e precisa fazer várias buscas nele, ordenar uma vez com O(n log n) e depois fazer buscas O(log n) é um ganho enorme em comparação com varreduras lineares O(n) toda vez.</p><h4>Renderizando Listas Ordenadas</h4><p>Tabelas de UI, placar de líderes, rankings de feed, resultados de busca-quase toda lista mostrada ao usuário foi ordenada antes de renderizar. Entender estabilidade de sort importa quando você encadeia sorts: ordena por data primeiro, depois por score, e quer que empates em score preservem a ordem de data.</p><h4>Pipelines de Processamento de Dados</h4><p>Pipelines ETL, engines de analytics e ferramentas de relatório frequentemente ordenam dados como passo intermediário-agrupando registros antes de agregação, ordenando eventos pra replay, encontrando duplicatas trazendo valores iguais para adjacência.</p><h3>Edge cases: comparador e mutação</h3><p>sort() <strong>muta</strong> o array. Precisa do original? [...arr].sort((a,b) =&gt; a - b).</p><p>Objetos: comparador deve retornar negativo/zero/positivo — não boolean.</p><p>Números: sempre (a, b) =&gt; a - b, nunca confiar no sort lexicográfico padrão.</p><h3>TL;DR — Ordenação</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*v-I4GCsimkaHS_Fnx5R1vw.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Busca binária (ep. 16):</strong> exige array ordenado — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript">Implementando busca binária</a></li><li><strong>ECMAScript:</strong> sort estável desde ES10 - <a href="https://jonathanjuliani.dev/pt-BR/blog/ecmascript-whats-new-from-es7-to-es10">Novidades ES7-ES10</a></li></ul><h3>Antes de fechar</h3><p>Qual algoritmo sua linguagem usa no sort nativo? Se viu cagada no post ou tem benchmark local, comenta.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on June 1, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ceb7133a10eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Conhecendo Algoritmos de Grafos com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/conhecendo-algoritmos-de-grafos-com-nodejs-e-javascript-c0d51b346220?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0d51b346220</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[data-structures]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 28 May 2024 00:00:25 GMT</pubDate>
            <atom:updated>2026-06-16T15:31:01.254Z</atom:updated>
            <content:encoded><![CDATA[<p>Grafo montado no ep. 7 não serve de nada sem <strong>travessia</strong>. Este episódio implementa <strong>BFS</strong> (largura) e <strong>DFS</strong> (profundidade) — base de menor caminho sem peso, ciclo e ordenação topológica.</p><p><strong>O que você vai aprender:</strong></p><ul><li>BFS com fila e Set de visitados</li><li>DFS recursivo e iterativo</li><li>Quando BFS acha caminho mais curto (sem peso)</li><li>Por que DFS detecta ciclo</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-graphs-with-nodejs-and-javascript">grafos (ep. 7)</a> e <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-queues-with-nodejs-and-javascript">pilhas/filas</a> (eps. 4–5).</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/meeting-graph-algorithms-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><h3>BFS e DFS: percorrer grafo sem loop infinito</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pKQO1qy_hnEpRsYW" /></figure><p>Lá no Post 7 a gente construiu uma estrutura de Graph com nós e arestas. Ter a estrutura de dados é ótimo, mas sem algoritmos pra navegar nela, é como ter um mapa que você não consegue usar. É disso que se trata esse post: <strong>Busca em Largura (BFS)</strong> e <strong>Busca em Profundidade (DFS)</strong> -os dois algoritmos fundamentais pra explorar um grafo.</p><p>Pra deixar as coisas concretas, vamos usar esse grafo em todos os exemplos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*4vWfGPIQ0Q-zMgjjDISYEQ.png" /></figure><p>Começando pelo nó A, BFS e DFS vão visitar todos os nós-mas em ordens completamente diferentes.</p><h3>Mão na Massa</h3><h4>A Teoria um Pouco Mais…, mais</h4><p><strong>BFS — Busca em Largura</strong></p><p>BFS usa uma <strong>fila</strong>. Ele visita todos os vizinhos do nó atual antes de ir mais fundo. Pensa como uma onda se expandindo: primeiro todos os nós a um passo de distância, depois todos a dois passos, e assim por diante.</p><p>Mesmo grafo com ordem de visita BFS a partir de A</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*CbnIYKetzHA-eOWuQHB18A.png" /></figure><p>Ordem de visita BFS a partir de A: A → B → C → D → E → F → G</p><p><strong>DFS — Busca em Profundidade</strong></p><p>DFS usa uma <strong>pilha</strong> (ou recursão). Ele mergulha o mais fundo possível em um caminho antes de voltar. Pensa como explorar um labirinto: vai até o fundo de um corredor, bate na parede, volta e tenta o próximo.</p><p>Mesmo grafo com ordem de visita DFS a partir de A</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*yJ32DZ_DkEsqb7NGmFx07A.png" /></figure><p>Ordem de visita DFS a partir de A: A → B → D → E → C → F → G</p><h4>Agora a Prática</h4><p>A gente vai reaproveitar o Graph do Post 7. Cola o arquivo completo pra começar:</p><pre>class Graph {<br>  constructor() {<br>    this.numberOfNodes = 0<br>    this.adjacentList = {}<br>  }<br> <br>  add(node) {<br>    this.adjacentList[node] = []<br>    this.numberOfNodes++<br>  }<br> <br>  addEdge(node1, node2) {<br>    this.adjacentList[node1].push(node2)<br>    this.adjacentList[node2].push(node1)<br>  }<br>}</pre><p>Agora vamos adicionar o método BFS na classe Graph:</p><pre>  bfs(start) {<br>    const visited = new Set()<br>    const queue = [start]<br>    const order = []<br> <br>    visited.add(start)<br> <br>    while (queue.length) {<br>      const node = queue.shift()<br>      order.push(node)<br> <br>      for (const neighbour of this.adjacentList[node]) {<br>        if (!visited.has(neighbour)) {<br>          visited.add(neighbour)<br>          queue.push(neighbour)<br>        }<br>      }<br>    }<br> <br>    return order<br>  }</pre><p>Explicando:</p><ul><li>Começamos com um Set pra rastrear nós visitados (pra não entrar em loop infinito em grafos com ciclos) e uma queue inicializada com o nó de partida.</li><li>A cada iteração a gente pega o nó da frente da fila (shift()), registra ele, e enfileira todos os seus vizinhos não visitados.</li><li>Por processar a fila de frente pra trás, visitamos os nós naturalmente nível por nível.</li></ul><p>Agora vamos adicionar o DFS:</p><pre>  dfs(start) {<br>    const visited = new Set()<br>    const order = []<br> <br>    const explore = (node) =&gt; {<br>      visited.add(node)<br>      order.push(node)<br>      for (const neighbour of this.adjacentList[node]) {<br>        if (!visited.has(neighbour)) {<br>          explore(neighbour)<br>        }<br>      }<br>    }<br> <br>    explore(start)<br>    return order<br>  }</pre><p>Explicando:</p><ul><li>Usamos uma função auxiliar recursiva explore que marca o nó como visitado, registra ele, depois imediatamente recursea em cada vizinho não visitado.</li><li>Como vamos fundo no primeiro vizinho antes de considerar os irmãos, obtemos a ordem em profundidade.</li></ul><p>Vamos testar os dois. Depois da classe, adiciona:</p><pre>const g = new Graph()<br>g.add(&#39;A&#39;)<br>g.add(&#39;B&#39;)<br>g.add(&#39;C&#39;)<br>g.add(&#39;D&#39;)<br>g.add(&#39;E&#39;)<br>g.add(&#39;F&#39;)<br>g.add(&#39;G&#39;)<br> <br>g.addEdge(&#39;A&#39;, &#39;B&#39;)<br>g.addEdge(&#39;A&#39;, &#39;C&#39;)<br>g.addEdge(&#39;B&#39;, &#39;D&#39;)<br>g.addEdge(&#39;B&#39;, &#39;E&#39;)<br>g.addEdge(&#39;C&#39;, &#39;F&#39;)<br>g.addEdge(&#39;C&#39;, &#39;G&#39;)<br> <br>console.log(&#39;BFS a partir de A:&#39;, g.bfs(&#39;A&#39;))<br>console.log(&#39;DFS a partir de A:&#39;, g.dfs(&#39;A&#39;))</pre><p>Roda o arquivo:</p><pre>node graph-algorithms.js</pre><p>Resultado esperado:</p><pre>BFS a partir de A: [ &#39;A&#39;, &#39;B&#39;, &#39;C&#39;, &#39;D&#39;, &#39;E&#39;, &#39;F&#39;, &#39;G&#39; ]<br>DFS a partir de A: [ &#39;A&#39;, &#39;B&#39;, &#39;D&#39;, &#39;E&#39;, &#39;C&#39;, &#39;F&#39;, &#39;G&#39; ]</pre><p>Os dois algoritmos visitaram os 7 nós, mas em ordens completamente diferentes. BFS foi largo (todos os vizinhos diretos de A primeiro), enquanto DFS foi fundo (seguiu o galho de B até o fim antes de tocar em C).</p><blockquote><em>Jon, posso fazer DFS iterativo em vez de recursivo?</em></blockquote><p>Sim! Substitui a função explore por uma pilha:</p><pre>  dfsIterative(start) {<br>    const visited = new Set()<br>    const stack = [start]<br>    const order = []<br> <br>    while (stack.length) {<br>      const node = stack.pop()<br>      if (visited.has(node)) continue<br>      visited.add(node)<br>      order.push(node)<br>      for (const neighbour of this.adjacentList[node]) {<br>        if (!visited.has(neighbour)) stack.push(neighbour)<br>      }<br>    }<br> <br>    return order<br>  }</pre><p>A versão iterativa usa uma pilha explícita em vez da call stack-mais seguro pra grafos muito grandes ou profundos onde a recursão pode estourar o limite de chamadas.</p><h3>Aonde Você Pode Usar/Ver</h3><h4>BFS — Menor Caminho em Grafos Sem Peso</h4><p>Como BFS se expande nível por nível, a primeira vez que ele chega num nó alvo, encontrou o <strong>caminho mais curto em termos de número de arestas</strong>. Essa é a base de algoritmos de menor caminho sem peso-pensa em “graus de separação” numa rede social, ou o mínimo de movimentos pra resolver um puzzle.</p><h4>BFS — Rastreamento Web</h4><p>Crawlers de buscadores começam de uma URL semente e percorrem a web via BFS seguindo links. BFS garante que eles descubram páginas próximas antes de mergulhar fundo em um domínio.</p><h4>DFS — Detecção de Ciclos</h4><p>Se o DFS visitar um nó que já está na pilha de recursão atual, existe um ciclo. É assim que gerenciadores de dependências detectam importações circulares.</p><h4>DFS — Ordenação Topológica</h4><p>Em um grafo direcionado acíclico (DAG), o DFS pode produzir uma ordenação topológica-uma sequência onde cada nó vem antes de todos os nós para os quais ele aponta. Sistemas de build e agendadores de tarefas usam isso pra determinar a ordem de execução.</p><h3>Edge cases: visitados, shift e stack overflow</h3><p>Sem Set de visitados, ciclo = loop infinito. Sempre marque ao <strong>enfileirar/empilhar</strong>, não só ao processar.</p><p>DFS recursivo em grafo profundo estoura call stack no Node (~10k frames). Versão iterativa com pilha explícita é mais segura.</p><p>BFS com arestas ponderadas <strong>não</strong> garante menor custo — aí entra Dijkstra (fila de prioridade).</p><h3>TL;DR — BFS vs DFS</h3><p>Alguém sabe adicionar essas tabelinhas aqui 👇 como algo que funcione no medium em vez de print? Deixa ali nos comentários, que agradeço!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/1*_oqEnebiRAMSiGioklPSbA.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Ordenação (ep. 15):</strong> preparar array pra busca — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript">Ordenando arrays</a></li><li><strong>Busca binária (ep. 16):</strong> fechamento da série — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript">Busca binária</a></li></ul><h3>Antes de fechar</h3><p>BFS ou DFS — qual você usou em produção? Se viu erro no grafo de exemplo, comenta.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/meeting-graph-algorithms-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 28, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/meeting-graph-algorithms-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0d51b346220" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Tries com NodeJS e Javascript | jonathanjuliani.dev]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-tries-com-nodejs-e-javascript-jonathanjuliani-dev-ecc725fc9366?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/ecc725fc9366</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 21 May 2024 00:00:52 GMT</pubDate>
            <atom:updated>2026-06-10T15:31:00.972Z</atom:updated>
            <content:encoded><![CDATA[<p>Autocomplete que sugere a cada tecla não varre o dicionário inteiro — usa <strong>prefixo</strong>. <strong>Trie</strong> (árvore de prefixos) compartilha nós entre palavras com começo igual.</p><p>Trie em JavaScript: insert, search, startsWith e autocomplete na prática. Árvore de prefixos com Node.js e casos de uso reais.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-maps-and-sets-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><p><strong>O que você vai aprender:</strong></p><ul><li>Nó por caractere e flag de fim de palavra</li><li>insert, search, startsWith</li><li>Memória vs hash table para vocabulário grande</li><li>Casos: busca, IDE, roteamento IP</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript">BST (ep. 12)</a> e <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-trees-with-nodejs-and-javascript">árvores (ep. 6)</a>.</p><h3>Trie: árvore de prefixos em JavaScript</h3><p>Já se perguntou como sua IDE sugere completações enquanto você digita, ou como um buscador mostra sugestões antes de você terminar a frase? Boa parte da resposta é a <strong>Trie</strong> (pronuncia “trai”, abreviação de re <strong>trie</strong> val-recuperação).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TvjSPXoH9H2QrnEtX95Dgg.png" /></figure><p>Uma Trie é uma árvore onde cada nó representa um único caractere. Você lê uma palavra seguindo um caminho da raiz até uma folha. Nós compartilhados entre palavras representam prefixos comuns-e é isso que torna a estrutura tão poderosa pra buscas de prefixo.</p><p>Trie para can, car, cat e bat com prefixos compartilhados</p><p>scene: en/data-structures-in-a-nutshell/trie-can-car-cat-bat</p><p>Interactive Excalidraw view is not available in this build.</p><p>Olha o diagrama acima. As palavras can, car e cat compartilham o prefixo ca-então elas compartilham o mesmo caminho c → a a partir da raiz. Você guarda o prefixo uma vez só e ramifica apenas onde as palavras divergem. Eficiente demais.</p><h3>Mão na Massa</h3><h4>Tá, só um pouquinho mais de teoria</h4><p>Tries trocam memória por velocidade. Pra um dicionário de strings, um hash map te dá O(1) pra lookup exato. Mas pra <strong>busca por prefixo</strong> (“me dá todas as palavras que começam com ca&quot;), um hash map não tem atalho-você varre tudo. Uma Trie faz isso em O(k) onde k é o tamanho do prefixo.</p><p>Cada nó numa Trie é basicamente um mapa de caracteres para nós filhos, mais um flag que marca se uma palavra completa termina ali.</p><h4>Agora a Prática</h4><p>Abre a IDE, cria um arquivo chamado trie.js e cola o código abaixo:</p><pre>class TrieNode {<br>  constructor() {<br>    this.children = {}<br>    this.isEndOfWord = false<br>  }<br>}<br> <br>class Trie {<br>  constructor() {<br>    this.root = new TrieNode()<br>  }<br> <br>  insert(word) {<br>    let node = this.root<br>    for (const char of word) {<br>      if (!node.children[char]) {<br>        node.children[char] = new TrieNode()<br>      }<br>      node = node.children[char]<br>    }<br>    node.isEndOfWord = true<br>  }<br>}</pre><p>Explicando:</p><ul><li>TrieNode tem um mapa children (caractere → nó filho) e o flag isEndOfWord.</li><li>Trie começa com um nó root vazio.</li><li>insert percorre caractere por caractere. Se um nó pro caractere atual não existir, ele cria. No fim da palavra seta isEndOfWord = true.</li></ul><p>Agora vamos adicionar search e startsWith:</p><pre>  search(word) {<br>    let node = this.root<br>    for (const char of word) {<br>      if (!node.children[char]) return false<br>      node = node.children[char]<br>    }<br>    return node.isEndOfWord<br>  }<br> <br>  startsWith(prefix) {<br>    let node = this.root<br>    for (const char of prefix) {<br>      if (!node.children[char]) return false<br>      node = node.children[char]<br>    }<br>    return true<br>  }</pre><p>A diferença entre os dois:</p><ul><li>search retorna true só se a palavra exata foi inserida (verifica isEndOfWord).</li><li>startsWith retorna true se qualquer palavra inserida começa com o prefixo dado (não liga pra isEndOfWord).</li></ul><p>Vamos adicionar também uma função de autocomplete que retorna todas as palavras com um dado prefixo:</p><pre>  autocomplete(prefix) {<br>    let node = this.root<br>    for (const char of prefix) {<br>      if (!node.children[char]) return []<br>      node = node.children[char]<br>    }<br>    const results = []<br>    this._collectWords(node, prefix, results)<br>    return results<br>  }<br> <br>  _collectWords(node, current, results) {<br>    if (node.isEndOfWord) results.push(current)<br>    for (const char of Object.keys(node.children)) {<br>      this._collectWords(node.children[char], current + char, results)<br>    }<br>  }</pre><p>Agora vamos testar tudo. Depois da classe Trie, cola o código abaixo:</p><pre>const trie = new Trie()<br>trie.insert(&#39;can&#39;)<br>trie.insert(&#39;car&#39;)<br>trie.insert(&#39;cat&#39;)<br>trie.insert(&#39;bat&#39;)<br>trie.insert(&#39;ball&#39;)<br>trie.insert(&#39;band&#39;)<br> <br>console.log(&#39;search(&quot;can&quot;):&#39;, trie.search(&#39;can&#39;))     // true<br>console.log(&#39;search(&quot;ca&quot;):&#39;, trie.search(&#39;ca&#39;))       // false (não é uma palavra completa)<br>console.log(&#39;search(&quot;dog&quot;):&#39;, trie.search(&#39;dog&#39;))     // false<br> <br>console.log(&#39;\nstartsWith(&quot;ca&quot;):&#39;, trie.startsWith(&#39;ca&#39;))   // true<br>console.log(&#39;startsWith(&quot;ba&quot;):&#39;, trie.startsWith(&#39;ba&#39;))    // true<br>console.log(&#39;startsWith(&quot;xy&quot;):&#39;, trie.startsWith(&#39;xy&#39;))    // false<br> <br>console.log(&#39;\nautocomplete(&quot;ca&quot;):&#39;, trie.autocomplete(&#39;ca&#39;))<br>console.log(&#39;autocomplete(&quot;ba&quot;):&#39;, trie.autocomplete(&#39;ba&#39;))</pre><p>Roda o arquivo:</p><pre>node trie.js</pre><p>Resultado esperado:</p><pre>search(&quot;can&quot;): true<br>search(&quot;ca&quot;): false<br>search(&quot;dog&quot;): false<br> <br>startsWith(&quot;ca&quot;): true<br>startsWith(&quot;ba&quot;): true<br>startsWith(&quot;xy&quot;): false<br> <br>autocomplete(&quot;ca&quot;): [ &#39;can&#39;, &#39;car&#39;, &#39;cat&#39; ]<br>autocomplete(&quot;ba&quot;): [ &#39;bat&#39;, &#39;ball&#39;, &#39;band&#39; ]</pre><p>autocomplete(&quot;ca&quot;) retornou [&#39;can&#39;, &#39;car&#39;, &#39;cat&#39;]-exatamente as palavras que inserimos que começam com &quot;ca&quot;. A Trie foi direto pro caminho c → a e coletou só o que estava lá, sem varrer o resto.</p><blockquote><em>Jon, e se eu quiser os resultados em ordem alfabética?</em></blockquote><p>O _collectWords itera Object.keys(node.children), e no V8 (Node.js) chaves string são iteradas na ordem de inserção. Se quiser ordem alfabética, ordena as chaves: for (const char of Object.keys(node.children).sort()). Uma linha só.</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Autocomplete em Buscas</h4><p>Esse é o caso de uso clássico. Toda vez que você digita numa caixa de busca e sugestões aparecem, provavelmente tem uma Trie (ou uma variante mais compacta como radix tree) fazendo o match de prefixo no servidor-ou até no cache do browser pra sugestões locais instantâneas.</p><h4>Correção Ortográfica e Texto Preditivo</h4><p>Teclados de celular usam estruturas parecidas com Trie pra sugerir a próxima palavra com base no que você já digitou. Corretores ortográficos baseados em dicionário também as usam pra enumerar rapidamente candidatos de correção.</p><h4>Tabelas de Roteamento IP</h4><p>Roteadores de rede guardam prefixos de endereços IP numa variante de Trie chamada <strong>PATRICIA trie</strong> ou <strong>radix tree</strong>. Quando um pacote chega, o roteador faz um match do prefixo mais longo pra decidir pra onde encaminhar-uma Trie torna isso rápido mesmo com milhões de prefixos.</p><h3>Edge cases: Object.create(null) e chaves perigosas</h3><p>Usar {} para filhos faz herdar toString, constructor do prototype - chave &quot;toString&quot; quebra tudo. Object.create(null) evita isso.</p><p>Trie esparsa com um filho por nível desperdiça memória — <strong>radix tree</strong> comprime caminhos lineares (tópico avançado).</p><h3>TL;DR — Trie</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*-Ay-A88tifYiOW3CHMdErw.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Algoritmos em grafos (ep. 14):</strong> outro tipo de travessia — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/meeting-graph-algorithms-with-nodejs-and-javascript">BFS e DFS</a></li><li><strong>Resumo da série:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/a-summary-on-the-most-used-ones">Mapa das 15 estruturas</a></li></ul><h3>Antes de fechar</h3><p>Já montou autocomplete ou filtro por prefixo? Comenta o gotcha que mais te pegou.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-tries-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 21, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-tries-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ecc725fc9366" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Árvore de Busca Binária com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-%C3%A1rvore-de-busca-bin%C3%A1ria-com-nodejs-e-javascript-4b69bc405fc4?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b69bc405fc4</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 14 May 2024 00:00:48 GMT</pubDate>
            <atom:updated>2026-06-09T15:31:00.730Z</atom:updated>
            <content:encoded><![CDATA[<p>Árvore de busca binária em JavaScript: inserção, busca, percorridas e limites na prática. Implementação completa com Node.js e exemplos.</p><p>Precisa manter dados <strong>ordenados</strong> enquanto insere e busca, sem reordenar o array inteiro? <strong>BST</strong> (árvore de busca binária) entrega busca em O(log n) <em>se</em> a árvore não degenerar.</p><p><em>[EN] </em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript"><em>english version can be found here</em></a><em>.<br>OBS 1: meus posts sempre estão </em><a href="https://jonathanjuliani.dev/"><em>aqui primeiro</em></a><em>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></p><p><strong>O que você vai aprender:</strong></p><ul><li>Regra esquerda &lt; nó &lt; direita</li><li>Inserir, buscar e percursos (in-order)</li><li>Por que dados já ordenados viram lista encadeada</li><li>Ligação com índices de banco</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-trees-with-nodejs-and-javascript">árvores (ep. 6)</a>.</p><h3>BST: busca binária em árvore</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kwrmw5qZwq3JYsnx" /></figure><p>Você já viu árvores binárias nessa série. A <strong>Árvore de Busca Binária (BST)</strong> é uma árvore binária com uma regra extra: para cada nó, todos os valores na <strong>subárvore esquerda são menores</strong>, e todos os valores na <strong>subárvore direita são maiores</strong>. Essa regra simples é o que torna a busca tão eficiente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*PGpmJteY6_k_HbUGEmuqYg.png" /></figure><p>Olha a árvore acima. A partir da raiz 8: tudo à esquerda ( 3, 1, 6, 4, 7) é menor que 8, e tudo à direita ( 10, 14, 13) é maior. Esse padrão se repete em cada nó. Se estou procurando o 6, começo em 8 → vou pra esquerda → chego em 3 → vou pra direita → chego em 6. Pronto-três comparações em vez de varrer a lista inteira.</p><h3>Mão na Massa</h3><h4>A Teoria da Coisa (um pouco mais fundo)</h4><p>A regra de ordenação da BST nos dá uma propriedade poderosa: <strong>um percurso in-order (esquerda → nó → direita) sempre retorna os valores em ordem crescente</strong>. Então a BST é basicamente uma estrutura que se mantém ordenada automaticamente conforme você insere e remove valores.</p><p>Operações em uma BST ideal (balanceada):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*hqB4-H_uFihYQ4OK5NzwMg.png" /></figure><blockquote><em>Jon, qual é o problema?</em></blockquote><p>O problema é o equilíbrio. Se você inserir valores em ordem crescente-tipo 1, 2, 3, 4, 5 -cada novo nó vai só pra direita do anterior. A árvore vira uma lista encadeada e tudo cai pra O(n). Árvores auto-balanceadas (AVL, Red-Black) resolvem isso automaticamente, mas aqui vamos manter simples.</p><h4>Agora a Prática</h4><p>Abre aí o seu VSCode ou a IDE que você preferir, cria um arquivo chamado bst.js, e cola o código abaixo:</p><pre>class Node {<br>  constructor(value) {<br>    this.value = value<br>    this.left = null<br>    this.right = null<br>  }<br>}<br> <br>class BST {<br>  constructor() {<br>    this.root = null<br>  }<br> <br>  insert(value) {<br>    const newNode = new Node(value)<br>    if (!this.root) {<br>      this.root = newNode<br>      return this<br>    }<br>    let current = this.root<br>    while (true) {<br>      if (value === current.value) return this // ignora duplicatas<br>      if (value &lt; current.value) {<br>        if (!current.left) { current.left = newNode; return this }<br>        current = current.left<br>      } else {<br>        if (!current.right) { current.right = newNode; return this }<br>        current = current.right<br>      }<br>    }<br>  }<br> <br>  search(value) {<br>    let current = this.root<br>    while (current) {<br>      if (value === current.value) return current<br>      current = value &lt; current.value ? current.left : current.right<br>    }<br>    return null<br>  }<br>}</pre><p>Explicando:</p><ul><li>Node é o contêiner-um valor, filho esquerdo e filho direito.</li><li>BST guarda a root e os métodos.</li><li>insert percorre a árvore comparando valores: menor vai pra esquerda, maior vai pra direita. Quando acha uma posição vazia, insere o novo nó.</li><li>search segue o mesmo caminho-esquerda se menor, direita se maior-até achar o valor ou cair fora da árvore.</li></ul><p>Agora vamos adicionar o <strong>percurso in-order</strong>. Ele lê a árvore de volta em ordem crescente. Adiciona esse método dentro da classe BST:</p><pre>  inOrder(node = this.root, result = []) {<br>    if (node) {<br>      this.inOrder(node.left, result)<br>      result.push(node.value)<br>      this.inOrder(node.right, result)<br>    }<br>    return result<br>  }</pre><p>O padrão é: visita a subárvore esquerda primeiro, depois empurra o nó atual, depois visita a subárvore direita. Por causa da regra de ordenação da BST, isso sempre retorna um array ordenado.</p><p>Vamos testar tudo. Depois da classe BST, adiciona:</p><pre>const tree = new BST()<br>tree.insert(8)<br>tree.insert(3)<br>tree.insert(10)<br>tree.insert(1)<br>tree.insert(6)<br>tree.insert(14)<br>tree.insert(4)<br>tree.insert(7)<br>tree.insert(13)<br> <br>console.log(&#39;Percurso in-order (deve ser ordenado):&#39;)<br>console.log(tree.inOrder())<br> <br>console.log(&#39;\nBusca pelo 6:&#39;)<br>const found = tree.search(6)<br>console.log(found ? `Encontrado: ${found.value}` : &#39;Não encontrado&#39;)<br> <br>console.log(&#39;\nBusca pelo 99:&#39;)<br>const notFound = tree.search(99)<br>console.log(notFound ? `Encontrado: ${notFound.value}` : &#39;Não encontrado&#39;)</pre><p>Roda o arquivo:</p><pre>node bst.js</pre><p>Resultado esperado:</p><pre>Percurso in-order (deve ser ordenado):<br>[<br>  1, 3,  4,  6,<br>  7, 8, 10, 13,<br>  14<br>]<br> <br>Busca pelo 6:<br>Encontrado: 6<br> <br>Busca pelo 99:<br>Não encontrado</pre><p>Olha o resultado do in-order-[1, 3, 4, 6, 7, 8, 10, 13, 14], perfeitamente ordenado, mesmo inserindo os valores em ordem aleatória. Isso é a regra da BST fazendo o trabalho silenciosamente a cada inserção.</p><blockquote><em>Jon, e a remoção de um nó?</em></blockquote><p>Remoção é a operação mais complicada na BST porque tem três casos:</p><ol><li><strong>Nó folha</strong> (sem filhos) — só remove.</li><li><strong>Um filho</strong> — substitui o nó pelo filho.</li><li><strong>Dois filhos</strong> — substitui o valor do nó pelo seu <strong>sucessor in-order</strong> (o menor valor na subárvore direita), depois deleta esse sucessor.</li></ol><p>Fica de desafio pra você implementar-se travar, deixa um comentário que a gente resolve junto!</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Índices de Banco de Dados</h4><p>Estruturas reais de índice de banco de dados, como B-Trees e B+-Trees, são descendentes diretas da ideia da BST. Elas mantêm as chaves em ordem para que consultas de intervalo ( WHERE idade BETWEEN 25 AND 40) possam usar busca binária em vez de varrer tudo. Entender BSTs é pré-requisito pra entender como índices funcionam de verdade.</p><h4>Coleções Ordenadas</h4><p>Sempre que precisar de uma coleção que se mantém ordenada enquanto você insere e deleta-sem reordenar em cada acesso-uma BST (ou variante balanceada) é a escolha natural. Runtimes de linguagens usam isso pra TreeMap/ TreeSet no Java, std::map/ std::set no C++, e estruturas similares.</p><h4>Autocomplete e Buscas por Intervalo</h4><p>BSTs permitem encontrar eficientemente todas as chaves que começam com um prefixo ou caem num intervalo. Uma trie (próximo post!) é especializada em busca de prefixo, mas pra intervalos numéricos ou comparáveis em geral, BSTs são a pedida.</p><h3>Edge cases: BST degenerada e remoção</h3><p>Inserir 1,2,3,4,5... em BST simples vira lista - O(n). Em produção: árvore balanceada (Red-Black) ou Map ordenado da runtime.</p><p>Remover nó com dois filhos exige substituto (sucessor in-order) — é o bug mais comum em implementação manual.</p><h3>TL;DR — BST</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/570/1*C6JnrDam4XNyrFtUsya9zw.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Trie (ep. 13):</strong> prefixo em vez de ordem total — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-tries-with-nodejs-and-javascript">Implementando Tries</a></li><li><strong>Busca binária em array (ep. 16):</strong> mesma ideia, sem ponteiros — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript">Busca binária</a></li></ul><h3>Antes de fechar</h3><p>Já debugou BST com in-order no console? Se viu erro no post ou implementou remoção, comenta.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 14, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b69bc405fc4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Mapa e Conjunto (Map/Set) com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-mapa-e-conjunto-map-set-com-nodejs-e-javascript-edb87e849912?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/edb87e849912</guid>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 14 May 2024 00:00:44 GMT</pubDate>
            <atom:updated>2026-06-03T15:32:00.843Z</atom:updated>
            <content:encoded><![CDATA[<p>Map e Set no JavaScript moderno: chaves de qualquer tipo, deduplicação eficiente e quando preferir em vez de objeto ou array.</p><p>{} só aceita chave string; array não deduplica. `Map` e `Set` (ES6) resolvem cache por objeto, contagem e &quot;valores únicos&quot; sem gambiarra.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-maps-and-sets-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><p><strong>O que você vai aprender:</strong></p><ul><li>API de Map: set, get, has, delete</li><li>API de Set: unicidade e Array.from(new Set(arr))</li><li>Map vs objeto literal</li><li>Ligação com hash table (ep. 8)</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-hash-tables-with-nodejs-and-javascript">hash tables (ep. 8)</a> ou <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-arrays-with-nodejs-and-javascript">arrays (ep. 2)</a>.</p><h3>Map e Set: chave-valor e valores únicos</h3><p>Maps e Sets são estruturas de dados muito conhecidas e geralmente usamos no dia-a-dia sem nem lembrar que estamos usando estruturas que foram feitas pra resolver alguns tipos de problemas igual um array ou tree (árvores)… Os Maps funcionam com uma estrutura de chave-valor, onde as chaves são únicas. Já os Sets são usados para criar uma coleção onde os valores são únicos. No mundo do NodeJS/Javascript tivemos na atualização do ECMAScript 6 (ES6), algumas ajudas que deixaram melhor e trouxeram formas mais eficientes de manipular os Maps e os Sets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ab4m0oCs8GqJHk0u" /></figure><h3>Mão na Massa</h3><p>Um Map é uma coleção de pares chave-valor onde cada chave é única e tem o seu valor, e seu valor pode ser de qualquer tipo (um número, um objeto, etc), e diferente dos objetos tradicionais em JavaScript, as chaves de um Map podem ser de qualquer tipo também, incluindo objetos, funções ou outros tipos primitivos.</p><p>Um Set é uma coleção de valores únicos. Assim como os Maps, os valores em um Set podem ser de qualquer tipo. Sets são particularmente úteis quando você precisa garantir que não haja duplicatas em uma coleção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yYIU4c4OtaOsGySy" /></figure><h3>Agora a Prática</h3><p>Agora abre aí o seu VSCode ou sua IDE favorita e vamos lá, crie um arquivo chamado map-and-set.js e cola o código abaixo pra começar com o Map:</p><pre>const map = new Map()<br>map.set(&#39;key&#39;, &#39;value&#39;)<br>map.set({}, &#39;object as key&#39;)<br>map.set(() =&gt; {}, &#39;function as key&#39;)<br>map.set(1, &#39;number as key&#39;)<br>map.set(&#39;key2&#39;, { key: &#39;key in the map value object&#39; })<br> <br>console.log(`map:`, map)<br>console.log(`map get &quot;key&quot;:`, map.get(&#39;key&#39;))<br>console.log(`map has &quot;key2&quot;:`, map.has(&#39;key2&#39;))<br>console.log(`map get &quot;key2&quot;:`, map.get(&#39;key2&#39;))<br> <br>map.delete(&#39;key&#39;)<br>console.log(`map deleted &quot;key&quot;:`, { map })</pre><p>Explicando o Map acima:</p><ul><li>Primeiro criamos um novo Map com const map = new Map().</li><li>map.set(&#39;key&#39;, &#39;value&#39;): Adiciona um novo par chave-valor ao Map, a chave é uma string key e o valor uma outra string value.</li><li>map.set({}, &#39;object as key&#39;): Adiciona um novo par chave-valor ao Map, onde a chave é um objeto vazio, e o valor é uma string.</li><li>map.set(() =&gt; {}, &#39;function as key&#39;): Adiciona um novo par chave-valor ao Map, onde a chave é uma função vazia, e o valor é uma string.</li><li>map.set(1, &#39;number as key&#39;): Adiciona um novo par chave-valor ao Map, onde a chave é um número 1, e o valor é uma string.</li><li>map.set(&#39;key2&#39;, { key: &#39;key in the map value object&#39; }): Adiciona um novo par chave-valor ao Map, onde a chave é uma string key2, e o valor é um objeto com uma chave key e um valor string.</li></ul><p>Depois disso temos alguns console.log para mostrar o que está acontecendo com o Map, onde:</p><ul><li>map: Mostra o Map completo.</li><li>map.get(&#39;key&#39;): Pega o valor da chave key.</li><li>map.has(&#39;key2&#39;): Verifica se a chave key2 existe no Map e retorna true ou false.</li><li>map.get(&#39;key2&#39;): Pega o valor da chave key2.</li><li>map.delete(&#39;key&#39;): Deleta a chave key do Map se ela existir.</li></ul><p>Agora vamos com o Set:</p><pre>const set = new Set()<br>set.add(&#39;valor1&#39;)<br>set.add(&#39;valor2&#39;)<br>set.add(&#39;valor3&#39;)<br>set.add(&#39;valor4&#39;)<br>set.add(&#39;valor5&#39;)<br> <br>console.log(`set:`, set)<br>console.log(`set has &quot;valor2&quot;:`, set.has(&#39;valor2&#39;))<br>console.log(`set keys:`, set.keys())<br> <br>set.add(&#39;valor1&#39;)<br>console.log(`set add &quot;valor1&quot; again:`, set)<br> <br>set.delete(&#39;valor1&#39;)<br>console.log(`set deleted &quot;valor1&quot;:`, set)</pre><p>Explicando o Set acima:</p><ul><li>Primeiro criamos um novo Set com const set = new Set().</li><li>set.add(&#39;valor1&#39;): Adiciona um novo valor ao Set, o valor é a string valor1.</li><li>set.add(&#39;valor2&#39;): Adiciona um novo valor ao Set, o valor é a string valor2.</li><li>set.add(&#39;valor3&#39;): Adiciona um novo valor ao Set, o valor é a string valor3.</li><li>set.add(&#39;valor4&#39;): Adiciona um novo valor ao Set, o valor é a string valor4.</li><li>set.add(&#39;valor5&#39;): Adiciona um novo valor ao Set, o valor é a string valor5.</li></ul><p>Depois disso temos alguns console.log para mostrar o que está acontecendo com o Set, onde:</p><ul><li>set: Mostra o Set completo.</li><li>set.has(&#39;valor2&#39;): Verifica se o valor valor2 existe no Set e retorna true ou false.</li><li>set.keys(): Retorna um iterador com as chaves do Set.</li><li>set.add(&#39;valor1&#39;): Vai tentar adicionar o valor valor1 de novo no Set, e logo em seguida fazemos um log onde vemos que o valor não é adicionado pois ele já existe no Set e não temos valores duplicados.</li><li>set.delete(&#39;valor1&#39;): Deleta o valor valor1 do Set se ele existir.</li></ul><h3>Aonde Você Pode Usar/Ver</h3><h4>Mapeamento com Maps</h4><p>Maps servem onde precisamos ter chave-valor que precisam ser acessadas e atualizadas de forma fácil e rápida, um exemplo pode ser quando trabalhamos com caches de dados, onde podemos usar Maps e ter uma relação de chave-valor pra recuperar de forma rápida as informações.</p><h4>Gerenciamento de Dados Únicos com Sets</h4><p>Você pode encontrar e utilizar os Sets para manipular listas de itens em casos onde a lista não deve conter itens duplicados, como em casos de gerenciamento de sessões de usuários ou um exemplo mais simples seria uma listas de tarefas, afinal não quereoms incluir a mesma tarefa 2x/3x na lista (em alguns casos né, aqui é só de exemplo).</p><h3>Edge cases: chave objeto e igualdade</h3><p>map.set(obj, 1) só recupera com a <strong>mesma referência</strong> de obj - não com objeto &quot;igual&quot; por valor.</p><p>Set usa SameValueZero - NaN é considerado igual a NaN, diferente de ===.</p><h3>TL;DR — Map vs Set</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*R5hWAm6Sr9lbJzHR8xUnug.png" /></figure><h3>Próximos passos</h3><ul><li><strong>BST (ep. 12):</strong> ordem total — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript">Árvore de busca binária</a></li><li><strong>ES6 features:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/ecmascript-whats-new-from-es7-to-es10">ECMAScript ES7–ES10</a></li></ul><h3>Antes de fechar</h3><p>Onde Map ou Set salvou seu código - cache, dedupe, sessão? Se viu cagada no post, comenta.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-maps-and-sets-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 14, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-maps-and-sets-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=edb87e849912" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Árvore de Busca Binária com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-%C3%A1rvore-de-busca-bin%C3%A1ria-com-nodejs-e-javascript-6f47d3454eba?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f47d3454eba</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[data-structures]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 14 May 2024 00:00:41 GMT</pubDate>
            <atom:updated>2026-06-04T15:31:00.972Z</atom:updated>
            <content:encoded><![CDATA[<p>Árvore de busca binária em JavaScript: inserção, busca, percorridas e limites na prática. Implementação completa com Node.js e exemplos.</p><p>Precisa manter dados <strong>ordenados</strong> enquanto insere e busca, sem reordenar o array inteiro? <strong>BST</strong> (árvore de busca binária) entrega busca em O(log n) <em>se</em> a árvore não degenerar.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><p><strong>O que você vai aprender:</strong></p><ul><li>Regra esquerda &lt; nó &lt; direita</li><li>Inserir, buscar e percursos (in-order)</li><li>Por que dados já ordenados viram lista encadeada</li><li>Ligação com índices de banco</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-trees-with-nodejs-and-javascript">árvores (ep. 6)</a>.</p><h3>BST: busca binária em árvore</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*raPQmOZonsTrlU_G" /></figure><p>Você já viu árvores binárias nessa série. A <strong>Árvore de Busca Binária (BST)</strong> é uma árvore binária com uma regra extra: para cada nó, todos os valores na <strong>subárvore esquerda são menores</strong>, e todos os valores na <strong>subárvore direita são maiores</strong>. Essa regra simples é o que torna a busca tão eficiente.</p><p>Árvore de busca binária: raiz 8, subárvore esquerda menor, direita maior</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*sWsX_6BE39QviSONWhZJ5g.png" /></figure><p>Olha a árvore acima. A partir da raiz 8: tudo à esquerda ( 3, 1, 6, 4, 7) é menor que 8, e tudo à direita ( 10, 14, 13) é maior. Esse padrão se repete em cada nó. Se estou procurando o 6, começo em 8 → vou pra esquerda → chego em 3 → vou pra direita → chego em 6. Pronto-três comparações em vez de varrer a lista inteira.</p><h3>Mão na Massa</h3><h4>A Teoria da Coisa (um pouco mais fundo)</h4><p>A regra de ordenação da BST nos dá uma propriedade poderosa: <strong>um percurso in-order (esquerda → nó → direita) sempre retorna os valores em ordem crescente</strong>. Então a BST é basicamente uma estrutura que se mantém ordenada automaticamente conforme você insere e remove valores.</p><p>Operações em uma BST ideal (balanceada):</p><blockquote><em>Jon, qual é o problema?</em></blockquote><p>O problema é o equilíbrio. Se você inserir valores em ordem crescente-tipo 1, 2, 3, 4, 5 -cada novo nó vai só pra direita do anterior. A árvore vira uma lista encadeada e tudo cai pra O(n). Árvores auto-balanceadas (AVL, Red-Black) resolvem isso automaticamente, mas aqui vamos manter simples.</p><h4>Agora a Prática</h4><p>Abre aí o seu VSCode ou a IDE que você preferir, cria um arquivo chamado bst.js, e cola o código abaixo:</p><pre>class Node {<br>  constructor(value) {<br>    this.value = value<br>    this.left = null<br>    this.right = null<br>  }<br>}<br> <br>class BST {<br>  constructor() {<br>    this.root = null<br>  }<br> <br>  insert(value) {<br>    const newNode = new Node(value)<br>    if (!this.root) {<br>      this.root = newNode<br>      return this<br>    }<br>    let current = this.root<br>    while (true) {<br>      if (value === current.value) return this // ignora duplicatas<br>      if (value &lt; current.value) {<br>        if (!current.left) { current.left = newNode; return this }<br>        current = current.left<br>      } else {<br>        if (!current.right) { current.right = newNode; return this }<br>        current = current.right<br>      }<br>    }<br>  }<br> <br>  search(value) {<br>    let current = this.root<br>    while (current) {<br>      if (value === current.value) return current<br>      current = value &lt; current.value ? current.left : current.right<br>    }<br>    return null<br>  }<br>}</pre><p>Explicando:</p><ul><li>Node é o contêiner-um valor, filho esquerdo e filho direito.</li><li>BST guarda a root e os métodos.</li><li>insert percorre a árvore comparando valores: menor vai pra esquerda, maior vai pra direita. Quando acha uma posição vazia, insere o novo nó.</li><li>search segue o mesmo caminho-esquerda se menor, direita se maior-até achar o valor ou cair fora da árvore.</li></ul><p>Agora vamos adicionar o <strong>percurso in-order</strong>. Ele lê a árvore de volta em ordem crescente. Adiciona esse método dentro da classe BST:</p><pre>  inOrder(node = this.root, result = []) {<br>    if (node) {<br>      this.inOrder(node.left, result)<br>      result.push(node.value)<br>      this.inOrder(node.right, result)<br>    }<br>    return result<br>  }</pre><p>O padrão é: visita a subárvore esquerda primeiro, depois empurra o nó atual, depois visita a subárvore direita. Por causa da regra de ordenação da BST, isso sempre retorna um array ordenado.</p><p>Vamos testar tudo. Depois da classe BST, adiciona:</p><pre>const tree = new BST()<br>tree.insert(8)<br>tree.insert(3)<br>tree.insert(10)<br>tree.insert(1)<br>tree.insert(6)<br>tree.insert(14)<br>tree.insert(4)<br>tree.insert(7)<br>tree.insert(13)<br> <br>console.log(&#39;Percurso in-order (deve ser ordenado):&#39;)<br>console.log(tree.inOrder())<br> <br>console.log(&#39;\nBusca pelo 6:&#39;)<br>const found = tree.search(6)<br>console.log(found ? `Encontrado: ${found.value}` : &#39;Não encontrado&#39;)<br> <br>console.log(&#39;\nBusca pelo 99:&#39;)<br>const notFound = tree.search(99)<br>console.log(notFound ? `Encontrado: ${notFound.value}` : &#39;Não encontrado&#39;)</pre><p>Roda o arquivo:</p><pre>node bst.js</pre><p>Resultado esperado:</p><pre>Percurso in-order (deve ser ordenado):<br>[<br>  1, 3,  4,  6,<br>  7, 8, 10, 13,<br>  14<br>]<br> <br>Busca pelo 6:<br>Encontrado: 6<br> <br>Busca pelo 99:<br>Não encontrado</pre><p>Olha o resultado do in-order-[1, 3, 4, 6, 7, 8, 10, 13, 14], perfeitamente ordenado, mesmo inserindo os valores em ordem aleatória. Isso é a regra da BST fazendo o trabalho silenciosamente a cada inserção.</p><blockquote><em>Jon, e a remoção de um nó?</em></blockquote><p>Remoção é a operação mais complicada na BST porque tem três casos:</p><ol><li><strong>Nó folha</strong> (sem filhos) — só remove.</li><li><strong>Um filho</strong> — substitui o nó pelo filho.</li><li><strong>Dois filhos</strong> — substitui o valor do nó pelo seu <strong>sucessor in-order</strong> (o menor valor na subárvore direita), depois deleta esse sucessor.</li></ol><p>Fica de desafio pra você implementar-se travar, deixa um comentário que a gente resolve junto!</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Índices de Banco de Dados</h4><p>Estruturas reais de índice de banco de dados, como B-Trees e B+-Trees, são descendentes diretas da ideia da BST. Elas mantêm as chaves em ordem para que consultas de intervalo ( WHERE idade BETWEEN 25 AND 40) possam usar busca binária em vez de varrer tudo. Entender BSTs é pré-requisito pra entender como índices funcionam de verdade.</p><h4>Coleções Ordenadas</h4><p>Sempre que precisar de uma coleção que se mantém ordenada enquanto você insere e deleta-sem reordenar em cada acesso-uma BST (ou variante balanceada) é a escolha natural. Runtimes de linguagens usam isso pra TreeMap/ TreeSet no Java, std::map/ std::set no C++, e estruturas similares.</p><h4>Autocomplete e Buscas por Intervalo</h4><p>BSTs permitem encontrar eficientemente todas as chaves que começam com um prefixo ou caem num intervalo. Uma trie (próximo post!) é especializada em busca de prefixo, mas pra intervalos numéricos ou comparáveis em geral, BSTs são a pedida.</p><h3>Edge cases: BST degenerada e remoção</h3><p>Inserir 1,2,3,4,5... em BST simples vira lista - O(n). Em produção: árvore balanceada (Red-Black) ou Map ordenado da runtime.</p><p>Remover nó com dois filhos exige substituto (sucessor in-order) — é o bug mais comum em implementação manual.</p><h3>TL;DR — BST</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/577/1*3eF9cEPdcOGsRfeaxLIy8A.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Trie (ep. 13):</strong> prefixo em vez de ordem total — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-tries-with-nodejs-and-javascript">Implementando Tries</a></li><li><strong>Busca binária em array (ep. 16):</strong> mesma ideia, sem ponteiros — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-with-nodejs-and-javascript">Busca binária</a></li></ul><h3>Antes de fechar</h3><p>Já debugou BST com in-order no console? Se viu erro no post ou implementou remoção, comenta.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 14, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f47d3454eba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Fila de Prioridade (Priority Queue) com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-fila-de-prioridade-priority-queue-com-nodejs-e-javascript-e519c184ac48?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/e519c184ac48</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[priority-queue]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Tue, 07 May 2024 00:00:27 GMT</pubDate>
            <atom:updated>2026-06-02T22:31:00.957Z</atom:updated>
            <content:encoded><![CDATA[<p>Fila comum é FIFO. <strong>Fila de prioridade</strong> atende quem tem score maior (ou menor) primeiro — fila de hospital, tarefas críticas, agendador. Aqui montamos em cima do min-heap do ep. 9.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-priority-queues-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><p><strong>O que você vai aprender:</strong></p><ul><li>enqueue / dequeue por prioridade, não por ordem de chegada</li><li>Reaproveitar heap em array</li><li>Min-heap vs max-heap na regra de negócio</li><li>Onde isso aparece fora de SO</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-heaps-with-nodejs-and-javascript">heaps (ep. 9)</a>. Se pulou árvores, revise <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-trees-with-nodejs-and-javascript">árvores (ep. 6)</a>.</p><h3>Priority queue: heap com prioridade explícita</h3><p>No post anterior falamos sobre Heaps, e agora vamos falar sobre Filas de Prioridade, que são uma estrutura de dados que se baseia em Heaps, então se você não viu o post sobre Heaps, recomendo dar uma olhada antes de continuar por aqui, vamos usar muito do que vimos em Heaps aqui.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R21IEa2eBA9KQ0pL" /></figure><p>Se Filas de Prioridade são baseadas nos Heaps, então imagino que você já sacou, que as Filas de Prioridade usam uma estrutura de árvores (Trees), no caso árvores binárias, lembra? Se não lembra, dá uma olhada no post sobre Árvores, que vai te ajudar a entender melhor o que é uma árvore binária. Mas em resumo as árvores binárias são aquelas que todos os elementos menores que o primeiro nó da árvore (root) vão pra um lado, e todos os maiores vão para outro lado, e aqui no caso das Filas de Prioridade isso vai seguir da mesma forma, mas não pelo valor do elemento em si, e sim pelo valor da prioridade desse elemento.</p><p>Aqui nas Filas de Prioridade vamos seguir a mesma linha, onde o nó principal, ou a raiz, é o elemento de maior ou o menor prioridade com base na prioridade dos outros elementos, da mesma forma que os Heaps aqui a gente pode escolher ter o elemento de maior prioridade no topo (root), ou de menor prioridade, basta mudarmos a implementação seguindo uma estrutura de max heap ou min heap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aUagFBQCtLe9XCMk" /></figure><h3>Mão na Massa</h3><p>Bora fazer uma estrutura inicial de Fila de Prioridade, vamos usar muito do que vimos no post anterior sobre Heaps, então se você leu, vai lembrar de muita coisa, e se não leu, recomendo dar uma olhada antes de continuar por aqui.</p><h3>Agora a Prática</h3><p>Agora abre aí o seu VSCode ou sua IDE favorita e vamos lá, crie um arquivo chamado priority-queue.js e cola o código abaixo:</p><pre>class PriorityQueue {<br>  constructor() {<br>    this.heap = []<br>  }<br> <br>  getParentIndex(i) {<br>    return Math.floor((i - 1) / 2)<br>  }<br>  getLeftChildIndex(i) {<br>    return 2 * i + 1<br>  }<br>  getRightChildIndex(i) {<br>    return 2 * i + 2<br>  }<br> <br>  enqueue(element, priority) {<br>    this.heap.push({ element, priority })<br>    this.heapifyUp() //vamos adicionar essa função em breve<br>  }<br> <br>  dequeue() {<br>    const min = this.heap[0]<br>    this.heap[0] = this.heap.pop()<br>    this.heapifyDown() //vamos adicionar essa função em breve<br>    return min.element<br>  }<br> <br>  isEmpty() {<br>    return this.heap.length === 0<br>  }<br>}</pre><p>Explicando o que temos até agora:</p><ul><li>Temos a classe PriorityQueue e a gente inicia o nosso heap como um array vazio (lembra é uma Fila de Prioridade, mas a estrutura é de Heap).</li><li>Temos os métodos getParentIndex, getLeftChildIndex e getRightChildIndex que são os mesmos métodos que usamos no post sobre Heaps, então se você leu, vai lembrar deles.</li><li>Temos o método enqueue em vez do insert que é o método que vai adicionar um elemento na nossa Fila de Prioridade, e ele recebe o element que é o elemento que queremos adicionar e a priority que é a prioridade desse elemento.</li><li>Temos o método dequeue que é o método que vai remover o elemento (seria processar no caso, mas aqui vamos só remover) de maior prioridade da nossa Fila de Prioridade, e ele retorna o elemento pra nós.</li><li>Temos o método isEmpty que é o método que vai verificar se a nossa Fila de Prioridade está vazia ou não.</li></ul><p>Só com isso ainda não conseguimos ver toda a mágica da coisa, então a gente precisa colocar mais algumas funções pra fazer a mágica acontecer, bora lá.</p><p>O heapifyUp é a função que vai ajustar a fila de Prioridade pra cima, ou seja, quando a gente inserir algum valor, ele vai subir na árvore de acordo com a prioridade até achar o lugar certo dele, então coloca esse código depois do isEmpty:</p><pre>  heapifyUp() {<br>    let index = this.heap.length - 1<br>    while (<br>      index !== 0 &amp;&amp;<br>      this.heap[this.getParentIndex(index)].priority &gt; this.heap[index].priority<br>    ) {<br>      ;[this.heap[this.getParentIndex(index)], this.heap[index]] = [<br>        this.heap[index],<br>        this.heap[this.getParentIndex(index)],<br>      ]<br>      index = this.getParentIndex(index)<br>    }<br>  }</pre><p>O heapifyDown é a função que vai ajustar o Heap pra baixo, ou seja, quando a gente remover algum valor, todos os outros elementos vão &quot;andar uma casa&quot; ou seja, descer na árvore até achar o lugar certo, então coloca esse código depois do heapifyUp:</p><pre>  heapifyDown() {<br>    let index = 0<br>    while (this.getLeftChildIndex(index) &lt; this.heap.length) {<br>      let smallerChildIndex = this.getLeftChildIndex(index)<br>      if (<br>        this.getRightChildIndex(index) &lt; this.heap.length &amp;&amp;<br>        this.heap[this.getRightChildIndex(index)].priority &lt; this.heap[smallerChildIndex].priority<br>      ) {<br>        smallerChildIndex = this.getRightChildIndex(index)<br>      }<br>      if (this.heap[index].priority &lt; this.heap[smallerChildIndex].priority) break<br>      ;[this.heap[index], this.heap[smallerChildIndex]] = [<br>        this.heap[smallerChildIndex],<br>        this.heap[index],<br>      ]<br>      index = smallerChildIndex<br>    }<br>  }</pre><blockquote><em>TA QUASE ACABANDO, PROMETO!</em></blockquote><p>Com tudo isso feito, vamos botar uns console.log bem raiz e criar uns itens na Fila pra ver se tá tudo funcionando como a gente espera, bora! Depois da classe PriorityQueue coloca o código abaixo (ou em outro arquivo se você preferir):</p><pre>const priorityQueue = new PriorityQueue()<br> <br>priorityQueue.enqueue(15, 1)<br>console.log(`Priority queue (enqueue 15):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(10, 2)<br>console.log(`Priority queue (enqueue 10):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(5, 3)<br>console.log(`Priority queue (enqueue 5):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(20, 4)<br>console.log(`Priority queue (enqueue 20):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(7, 5)<br>console.log(`Priority queue (enqueue 7):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(25, 6)<br>console.log(`Priority queue (enqueue 25):`, { queue: priorityQueue.heap })<br> <br>priorityQueue.enqueue(1, 7)<br>console.log(`Priority queue (enqueue 1):`, { queue: priorityQueue.heap })</pre><p>Explicando:</p><ul><li>A gente cria uma nova instância da nossa PriorityQueue.</li><li>A gente adiciona alguns elementos na nossa Fila de Prioridade com a função enqueue, lembrando que aqui, não colocamos só um valor, temos que colocar a prioridade desse valor também, senão a gente não consegue fazer a mágica acontecer.</li><li>A gente dá um console.log pra ver como tá a nossa Fila de Prioridade depois de cada elemento que a gente adiciona.</li></ul><p>Agora a última parte pra gente ver se ta tudo certinho, vamos adicionar isso aqui:</p><pre>console.log(`dequeue 1/3:`, {<br>  rootValue: priorityQueue.dequeue(),<br>  heap: priorityQueue.heap,<br>})<br> <br>console.log(`dequeue 2/3:`, {<br>  rootValue: priorityQueue.dequeue(),<br>  heap: priorityQueue.heap,<br>})<br> <br>console.log(`dequeue 3/3:`, {<br>  rootValue: priorityQueue.dequeue(),<br>  heap: priorityQueue.heap,<br>})</pre><p>Explicando:</p><ul><li>A gente vai remover ou “processar” os elementos da nossa Fila de Prioridade com a função dequeue.</li><li>A função dequeue vai remover o elemento de maior prioridade da nossa Fila e vai retornar esse elemento pra gente.</li><li>A gente dá um console.log pra ver como tá a nossa Fila de Prioridade depois de cada elemento que a gente remove.</li><li>Fazemos 3 remoções e esperamos que os elementos sejam removidos na ordem de prioridade deles.</li></ul><p>Se tudo deu certo, você deve ver algo parecido com isso no seu terminal quando você executar o código:</p><pre>dequeue 1/3: {<br>  rootValue: 10,<br>  heap: [<br>    { element: 20, priority: 2 },<br>    { element: 5, priority: 4 },<br>    { element: 30, priority: 3 },<br>    { element: 1, priority: 7 },<br>    { element: 15, priority: 5 },<br>    { element: 25, priority: 6 }<br>  ]<br>}<br>dequeue 2/3: {<br>  rootValue: 20,<br>  heap: [<br>    { element: 30, priority: 3 },<br>    { element: 5, priority: 4 },<br>    { element: 25, priority: 6 },<br>    { element: 1, priority: 7 },<br>    { element: 15, priority: 5 }<br>  ]<br>}<br>dequeue 3/3: {<br>  rootValue: 30,<br>  heap: [<br>    { element: 5, priority: 4 },<br>    { element: 15, priority: 5 },<br>    { element: 25, priority: 6 },<br>    { element: 1, priority: 7 }<br>  ]<br>}</pre><p>Eu não coloquei ali em cima o console.log de cada enqueue porque ia ficar muito grande o post aqui, mas se os logs do dequeue estão certos, você deve ter os mesmos valores que eu aqui certinho.</p><p>Nessa Fila de Prioridade, a implementação que seguimos foi de Min-Heap, então a menor prioridade (“1” no caso) será o elemento root, imaginamos nesse caso que o 1 seria o primeiro a ser processado/executado, e depois o 2, e assim por diante. Se você quiser trabalhar com Max-Heap, basta inverter as comparações de prioridade nos métodos heapifyUp e heapifyDown, ai os elementos de maior prioridade vão ser os primeiros a serem processados/executados.</p><p>Vou parar o código por aqui e deixar pra você testar, e se você reparou, usamos um Array pra facilitar a estrutura do Heap, o que acha de tentar usar a estrutura de árvore que fizemos uns posts atrás pra montar essa Fila? Será que dá pra fazer? Se fizer, me avisa, quero ver!</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Gerenciamento de Recursos</h4><p>Filas de prioridade são perfeitas para gerenciar recursos em sistemas computacionais onde diferentes processos têm diferentes prioridades de acesso a recursos, como CPU e memória, mas aqui estamos falando de casos complexos e voltados para o sistema operacional, então não é algo que você vai usar no seu dia a dia (eu acho).</p><h4>Simulações e Agendamentos</h4><p>Falando em casos mais voltados pra apps, sites, etc, podemos usar as Filas de Prioridade em simulações, execução e agendamento de eventos, por exemplo um sistema de Fila online para um restaurante onde idosos/gestantes vão ter uma prioridade na fila, ou também em jogos, onde ações de personagens podem ter prioridades diferentes, ou até mesmo em sistemas de busca, onde a busca de um usuário pode ter prioridade sobre a busca de outro, enfim, são muitas possibilidades.</p><h3>Edge cases: prioridade dinâmica e empate</h3><p>Mudar a prioridade de um item <strong>no meio</strong> da fila exige reordenar o heap (ou remover e reinserir). Não existe “só atualizar um número” sem heapify.</p><p>Empate de prioridade: defina desempate (FIFO por timestamp) na comparação — senão a ordem fica imprevisível.</p><h3>TL;DR — Fila de prioridade</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*TFne1u5_wR_vrzTLGOfdhQ.png" /></figure><h3>Próximos passos</h3><ul><li><strong>BST (ep. 12):</strong> coleção ordenada — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-binary-search-trees-with-nodejs-and-javascript">Árvore de busca binária</a></li><li><strong>Maps (ep. 11):</strong> outro jeito de indexar por chave — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-maps-and-sets-with-nodejs-and-javascript">Maps e Sets</a></li></ul><h3>Antes de fechar</h3><p>Já priorizou job, alerta ou fila de usuário? Se implementou com árvore em vez de array, quero ver nos comentários.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-priority-queues-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 7, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-priority-queues-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote><em>pra receber os updates antes de ver no Medium, se cadastra aqui na </em><a href="https://jonathanjuliani.dev/pt-BR/newsletter"><em>NewsLetter</em></a><em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e519c184ac48" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando Heap com NodeJS e Javascript]]></title>
            <link>https://medium.com/@jonathanjuliani/implementando-heap-com-nodejs-e-javascript-7a0efc5430e4?source=rss-d03446c44cae------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a0efc5430e4</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[algoritmos]]></category>
            <dc:creator><![CDATA[Jonathan Juliani]]></dc:creator>
            <pubDate>Wed, 01 May 2024 00:00:46 GMT</pubDate>
            <atom:updated>2026-05-30T15:31:00.460Z</atom:updated>
            <content:encoded><![CDATA[<p>Heap em JavaScript: min-heap em array, índices dos filhos e uso em filas de prioridade. Tutorial passo a passo com Node.js.</p><p>Precisa sempre saber qual é o <strong>menor</strong> (ou maior) item sem varrer a lista inteira? <strong>Heap</strong> mantém esse elemento no topo em O(log n) por inserção/remoção — base de fila de prioridade e heapsort.</p><blockquote>[EN] <a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-heaps-with-nodejs-and-javascript">english version can be found here</a>.<br>OBS 1: meus posts sempre estão <a href="https://jonathanjuliani.dev/">aqui primeiro</a>.<br>OBS 2: pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><p><strong>O que você vai aprender:</strong></p><ul><li>Min-heap vs max-heap</li><li>Representar heap em array (índices pai/filho)</li><li>insert, heapify e extrair o mínimo</li><li>Relação com árvore binária sem montar nós com ponteiros</li></ul><p><strong>Pré-requisitos:</strong> <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-trees-with-nodejs-and-javascript">árvores (ep. 6)</a> e <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-hash-tables-with-nodejs-and-javascript">hash tables (ep. 8)</a>.</p><h3>Heap binário: min-heap em array</h3><p>Vamos lá, Heaps são árvores (trees), o que acontece aqui é que os Heads tem uma estrutura de certa forma pré-definida, já vamos ver o que é essa estrutura que um Heap segue. Árvores do tipo Heap servem na maioria dos casos pra gerenciar conjuntos de dados que precisam ter algum tipo de prioridade e também pra implementação de algoritmos de ordenação.</p><p>Um heap é uma árvore igual falei ali em cima, e segue a estrutura de árvore binária, lembra o que é isso? Se não lembra volta ali na implementação de árvores…(brincadeira) em resumo as árvores binárias são aquelas que todos os elementos menores que o primeiro nó da árvore vão pra um lado, e todos os maiores vão para outro lado, tem uns detalhes mas vamos ver isso depois.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EM0-P9NkIeKrn_kY" /></figure><p>Aqui nos Heaps, seguimos a mesma linha, onde o nó principal, ou a raiz, é o maior ou o menor valor com base nos outros valores da árvore, com base nisso temos dois nomes conhecidos para os Heaps, o max-heap (a raiz é o maior) e o min-heap (a raiz é o menor). Essas definições ajudam nas operações de inserção e remoção, mantendo sempre o maior ou o menor elemento na raiz (dependendo o que queremos), ou seja, o acesso ao elemento &quot;mais importante&quot; seria sempre no primeiro nó.</p><h3>Mão na Massa</h3><p>Bora fazer um min-heap, ou seja, onde o menor valor sempre vai estar na raiz…Pra fazer isso, vamos criar uma estrutura parecida com de uma árvore, mas aqui começa a complicar um pouco, porque pra ajudar, a gente pode usar um array, em vez de objetos igual na árvore, mas dá pra fazer seguindo a estrutura de árvore que vimos antes, só vai precisar de umas contas pra achar os índices dos filhos e dos pais, enfim, podemos deixar pra um próximo, vamos lá!</p><h3>Agora a Prática</h3><p>Agora abre aí o seu VSCode ou sua IDE favorita e vamos lá, crie um arquivo chamado heaps.js e cola o código abaixo:</p><pre>class MinHeap {<br>  constructor() {<br>    this.heap = []<br>  }<br> <br>  getParentIndex(i) {<br>    return Math.floor((i - 1) / 2)<br>  }<br>  getLeftChildIndex(i) {<br>    return 2 * i + 1<br>  }<br>  getRightChildIndex(i) {<br>    return 2 * i + 2<br>  }<br> <br>  insert(key) {<br>    this.heap.push(key)<br>    this.heapifyUp()<br>  }<br>}</pre><p>Explicando:</p><ul><li>MinHeap é a classe que criamos que vai dar vida ao Heap</li><li>No constructor a gente inicializa o array heap que vai ser o nosso Heap de fato (onde vamos guardar os valores)</li><li>getParentIndex, getLeftChildIndex e getRightChildIndex são funções auxiliares que vão nos ajudar a achar os índices dos pais e dos filhos de um nó</li><li>insert é a função que vai inserir um valor no Heap</li></ul><p>Só com isso ainda não conseguimos ver toda a mágica do Heap, a gente precisa colocar mais algumas funções pra fazer a mágica acontecer, então depois do insert vamos colocar mais algumas funções, vou colocar uma por uma e explicar o que cada uma vai fazer.</p><p>O heapifyUp é a função que vai ajustar o Heap pra cima, ou seja, quando a gente inserir algum valor, ele vai subir na árvore até achar o lugar certo dele, então cola o código abaixo depois do insert:</p><pre>  heapifyUp() {<br>    let index = this.heap.length - 1<br>    while (index !== 0 &amp;&amp; this.heap[this.getParentIndex(index)] &gt; this.heap[index]) {<br>      ;[this.heap[this.getParentIndex(index)], this.heap[index]] = [<br>        this.heap[index],<br>        this.heap[this.getParentIndex(index)],<br>      ]<br>      index = this.getParentIndex(index)<br>    }<br>  }</pre><p>O heapifyDown é a função que vai ajustar o Heap pra baixo, ou seja, quando a gente remover algum valor, todos os outros elementos vão &quot;andar uma casa&quot; ou seja, descer na árvore até achar o lugar certo, então cola o código abaixo depois do heapifyUp:</p><pre>  heapifyDown() {<br>    let index = 0<br>    while (this.getLeftChildIndex(index) &lt; this.heap.length) {<br>      let smallerChildIndex = this.getLeftChildIndex(index)<br>      if (<br>        this.getRightChildIndex(index) &lt; this.heap.length &amp;&amp;<br>        this.heap[this.getRightChildIndex(index)] &lt; this.heap[smallerChildIndex]<br>      ) {<br>        smallerChildIndex = this.getRightChildIndex(index)<br>      }<br>      if (this.heap[index] &lt; this.heap[smallerChildIndex]) break<br>      ;[this.heap[index], this.heap[smallerChildIndex]] = [<br>        this.heap[smallerChildIndex],<br>        this.heap[index],<br>      ]<br>      index = smallerChildIndex<br>    }<br>  }</pre><p>O extractMin é a função que vai remover o menor valor do Heap, ou seja, o valor que está na raiz, e depois vai ajustar o Heap pra baixo, ou seja, andar uma casa com os outros valores até tudo ficar no lugar certo e garantir que o valor na raiz seja ainda o menor valor, então coloca o código abaixo depois do heapifyDown:</p><pre>  extractMin() {<br>    if (!this.heap.length) return null<br>    if (this.heap.length === 1) return this.heap.pop()<br> <br>    const min = this.heap[0]<br>    this.heap[0] = this.heap.pop()<br>    this.heapifyDown()<br>    return min<br>  }</pre><blockquote><em>TA QUASE ACABANDO, PROMETO!</em></blockquote><p>Com tudo isso feito, vamos botar uns console.log raiz, criar uns elementos e ver como o Heap vai se comportar e ver se tá tudo funcionando como a gente espera, bora, cola o código abaixo no seu arquivo heaps.js depois da classe MinHeap:</p><pre>const minHeap = new MinHeap()<br> <br>minHeap.insert(10)<br>console.log(`minHeap insert 10:`, { heap: minHeap.heap })<br> <br>minHeap.insert(5)<br>console.log(`minHeap insert 5:`, { heap: minHeap.heap })<br> <br>minHeap.insert(15)<br>console.log(`minHeap insert 15:`, { heap: minHeap.heap })<br> <br>minHeap.insert(20)<br>console.log(`minHeap insert 20:`, { heap: minHeap.heap })<br> <br>minHeap.insert(30)<br>console.log(`minHeap insert 30:`, { heap: minHeap.heap })<br> <br>minHeap.insert(2)<br>console.log(`minHeap insert 2:`, { heap: minHeap.heap })</pre><p>Explicando:</p><ul><li>A gente cria um novo Heap com const minHeap = new MinHeap()</li><li>Depois a gente insere alguns valores no Heap com insert</li></ul><p>Agora a última parte pra gente ver se ta tudo certinho, depois dos inserts acima, coloca isso aqui:</p><pre>console.log(`1 extraction of current min value:`, {<br>  currentMinValue: minHeap.extractMin(),<br>  heap: minHeap.heap,<br>})<br> <br>console.log(`2 extraction of current min value:`, {<br>  currentMinValue: minHeap.extractMin(),<br>  heap: minHeap.heap,<br>})<br> <br>console.log(`3 extraction of current min value:`, {<br>  currentMinValue: minHeap.extractMin(),<br>  heap: minHeap.heap,<br>})</pre><p>Explicando:</p><ul><li>Estamos fazendo 3 logs, já com um objeto que trás o menor valor e como o Heap ta depois da remoção</li><li>A gente chama a função extractMin pra remover o menor valor do Heap (que esperamos que seja o valor que ta na raiz)</li><li>Depois a gente chama de novo a função extractMin pra remover o menor valor atual do Heap (que esperamos de novo que seja o valor que ta na raiz)</li></ul><p>Fazemos isso 3 vezes pra ver se ta tudo certinho, se tudo deu certo, você deve ver algo parecido com isso no seu terminal:</p><pre>&gt; node ./heaps.js<br><br>&gt; minHeap insert 10: { heap: [ 10 ] }<br>&gt; minHeap insert 5: { heap: [ 5, 10 ] }<br>&gt; minHeap insert 15: { heap: [ 5, 10, 15 ] }<br>&gt; minHeap insert 20: { heap: [ 5, 10, 15, 20 ] }<br>&gt; minHeap insert 30: { heap: [ 5, 10, 15, 20, 30 ] }<br>&gt; minHeap insert 2: { heap: [ 2, 10, 5, 20, 30, 15 ] }<br>&gt; 1 extraction of current min value: { currentMinValue: 2, heap: [ 5, 10, 15, 20, 30 ] }<br>&gt; 2 extraction of current min value: { currentMinValue: 5, heap: [ 10, 20, 15, 30 ] }<br>&gt; 3 extraction of current min value: { currentMinValue: 10, heap: [ 15, 20, 30 ] }</pre><blockquote><em>Me avisa e coloca um comentário aqui se você descobrir porque quando incluimos o 2 ele ficou na posição certa como raiz (antes do 10), mas porque o 10 não ficou depois do 5, e sim depois do 2?</em></blockquote><p>Vou parar o código por aqui e deixar pra você testar, o que acha de tentar aplicar esse conceito, mas na estrutura de árvore que fizemos uns posts atrás? Será que dá pra fazer? Se fizer, me avisa, quero ver!</p><h3>Aonde Você Pode Usar/Ver</h3><h4>Gerenciamento de Filas de Prioridade</h4><p>Heaps são ideais para implementar filas de prioridade, onde elementos são processados com base na prioridade em vez de na ordem de chegada. Isso é essencial em sistemas operacionais, simulações, algoritmos de agendamento, enfim, variaas aplicações.</p><h4>Algoritmos de Ordenação e Busca</h4><p>Heaps facilitam a implementação de algoritmos de ordenação eficientes, como o heapsort, e são usados também em algoritmos de busca “menor caminho” que vamos ver mais pra frente, que basicamente são algoritmos que buscam elementos em grafos tentando realizar o menor caminho possível entre os elementos dos grafos, como o Dijkstra.</p><h3>Edge cases: heapify após insert e dados arbitrários</h3><p>Esquecer heapify depois de push no array quebra a propriedade do heap - o índice 0 deixa de ser o mínimo real.</p><blockquote><em>“Tá Jon, heap só serve pra número?”</em></blockquote><p>Não. Basta definir prioridade (campo priority ou comparador). O array guarda objetos; a comparação usa a regra que você passar.</p><h3>TL;DR — Heap</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*wlryaE1ZXUQv8R1t_Ou39g.png" /></figure><h3>Próximos passos</h3><ul><li><strong>Fila de prioridade (ep. 10):</strong> heap na API — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-priority-queues-with-nodejs-and-javascript">Implementando Filas de Prioridade</a></li><li><strong>Ordenação (ep. 15):</strong> heapsort na prática — <a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/sorting-arrays-with-nodejs-and-javascript">Ordenando arrays</a></li></ul><h3>Antes de fechar</h3><p>Já usou fila de prioridade em job, alerta ou jogo? Comenta — e se o exemplo do insert(2) te fez pensar, manda sua versão do heapify.</p><p><em>Originally published at </em><a href="https://jonathanjuliani.dev/pt-BR/blog/data-structures-in-a-nutshell/implementing-heaps-with-nodejs-and-javascript"><em>https://jonathanjuliani.dev</em></a><em> on May 1, 2024.<br></em><a href="https://jonathanjuliani.dev/en-US/blog/data-structures-in-a-nutshell/implementing-heaps-with-nodejs-and-javascript"><em>English version</em></a><em> also available at jonathanjuliani.dev.</em></p><blockquote>pra receber os updates antes de ver no Medium, se cadastra aqui na <a href="https://jonathanjuliani.dev/pt-BR/newsletter">NewsLetter</a>.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a0efc5430e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>