LogRitmo navegador / ativofase / 02LR / fase 02 · ativa
phase 02 / graphs
01 / grafos

Breadth-First Search (BFS).

Expanda em camadas, como uma onda que mede distância.

ver A*
visualização passo a passo

Visita primeiro os vizinhos mais próximos.

palco / BFSfronteira / caminho
grafo / 08 nós / 11 arestasvisitas 0fronteira 1percurso / sem pesos
AorigemBBCCDDEEFFGGHdestino
atual visitado caminho origem A → destino H
telemetria / grafo
passo00grafo carregado — origem pronta
nós visitados00travessia observada
fronteira01próximos candidatos
arestas no caminho—sem custo ponderado
playback observado · grafo

Duração que aconteceu.

Execuções concluídas nesta bancada, medidas durante o playback ativo no navegador e salvas apenas neste dispositivo.

média / últimas 0—BFS · armazenamento local
sem registros ainda

Execute o algoritmo até o fim para transformar esta bancada em uma série de medições reais.

/ leitura da fronteira

Breadth-First Search (BFS)
explora a rede.

Breadth-First Search (BFS) é uma travessia: visita nós sem usar pesos para decidir o próximo passo. Use em redes não ponderadas quando a primeira chegada representa o menor número de arestas.

↗

fila por camadas
BFS encontra menor caminho em número de arestas quando o grafo não tem pesos relevantes.

complexidade
melhorO(V + E)
médioO(V + E)
piorO(V + E)

Com lista de adjacência, é ideal para menor caminho em grafos sem pesos; a bancada usa um grafo pequeno e uma lista fixa de arestas para tornar cada visita visível.

Como ler esta réguaEla não mede o tempo do seu aparelho: compara como o trabalho tende a crescer quando a rede aumenta em V (nós) e E (ligações).
operações
vértices (V) e arestas (E)O(V + E)O(V²)O(E log V)O(E)
O(V + E) · Percurso do grafo

V é o número de vértices (nós) e E é o número de arestas (ligações). BFS e DFS visitam cada parte necessária do grafo uma vez.

Adicionar nós e ligações aumenta o trabalho de forma proporcional ao tamanho da rede explorada.
comparação / duas técnicas

Compare o crescimento lado a lado

Escolha duas técnicas diferentes. As curvas usam a mesma escala visual para explicar como o custo tende a aumentar.

Comparações prontasaplique um par didático
vértices (V) e arestas (E)operações

Use este par para comparar a exploração de um grafo não ponderado com o custo adicional de priorizar caminhos de menor distância. Breadth-First Search tende a crescer mais devagar do que Dijkstra quando aumentam vértices (V) e arestas (E). Isso descreve tendência assintótica, não mede o tempo do seu aparelho.

/ leitura técnica da travessia

A fila preserva
a distância das camadas.

Breadth-First Search não escolhe o próximo nó por peso, por geometria ou por uma previsão. A fila FIFO mantém primeiro os nós descobertos mais perto da fonte. Por isso, em um grafo não ponderado, cada primeira descoberta representa o menor número possível de arestas até aquele nó.

01 / CAMADAS

A frente da fila mede quantos saltos já foram dados.

A fonte começa na distância zero. Ao remover um nó de distância k, cada vizinho inédito entra com distância k + 1. Nós já descobertos da mesma camada deixam a fila antes dos nós mais distantes.

02 / INVARIANTE

Marcar ao enfileirar evita uma descoberta duplicada.

Quando um vizinho entra na fila, ele já recebe visited, parent e sua distância. Em ciclos, isso impede novas cópias do mesmo nó; em rotas concorrentes, preserva a primeira chegada, que é mínima em quantidade de arestas.

03 / CAMINHO

O predecessor registra uma rota, não uma única verdade.

Seguir parent do destino até a fonte reconstrói um caminho mínimo. Se houver várias rotas com o mesmo número de arestas, a ordem dos vizinhos pode mudar o predecessor escolhido, sem alterar a distância correta.

/ custo, memória e cobertura

O(V + E) percorre relações; não torna a fronteira gratuita.

Com lista de adjacência, cada vértice é descoberto no máximo uma vez e cada aresta é examinada em tempo constante, resultando em O(V + E). A fila, as marcas, as distâncias e os predecessores usam O(V) adicional. Em grafos muito ramificados, a largura de uma camada pode concentrar boa parte dessa memória na fronteira.

TRAVESSIAO(V + E)Com lista de adjacência.
MEMÓRIA AUXILIARO(V)Fila e registros por vértice.
DISTÂNCIA GARANTIDAsaltosEm arestas de custo uniforme.
GRAFO DESCONEXOparcialUma fonte cobre só o que alcança.
ESCOLHA PELO SIGNIFICADO DA ARESTA

“Mais curto” só significa menos saltos quando cada salto vale o mesmo.

BFS é apropriado para labirintos com movimentos unitários, graus de separação, alcance em rede e saídas mais próximas. Se uma aresta puder custar mais que outra, uma rota com menos passos pode ser mais cara. Nessa situação, a fila FIFO não substitui a prioridade por menor custo usada por Dijkstra.

MODELOPRÓXIMO NÓGARANTIA
BFSfila FIFOmenos arestas
DFSpilha ou recursãoexplora ramos
Dijkstramenor custo pendentepesos não negativos
DECISÃO DE ENGENHARIA

Comece pela unidade que o problema quer minimizar.

Escolha BFS quando a pergunta for “quem chega em menos transições?” e cada transição tiver o mesmo custo. Para a saída mais próxima ou a fonte mais próxima, inicialize todas as fontes na fila com distância zero: a primeira descoberta mede a menor distância ao conjunto de origens. Em um digrafo, respeite a direção; em um grafo desconexo, reconheça que nós fora da componente alcançável permanecem sem rota a partir da fonte escolhida.

/ por baixo do palco

Pseudocódigo e
implementação.

A mesma rede pode ser explorada com uma fila, uma pilha ou uma função de custo. Os trechos mostram o núcleo da decisão; funções de apoio, como recuperar a rota ou escolher o menor custo, aparecem com nomes descritivos para manter o foco da explicação.

01coloque a origem na fila
02retire o primeiro nó
03visite vizinhos não vistos
04adicione vizinhos ao fim
05repita até encontrar o alvo
/ implementação sincronizada
function bfs(graph, start, goal) { // Explore the graph level by level  const queue = [start];  let head = 0;  const visited = new Set([start]);  while (head < queue.length) {    const node = queue[head++];    if (node === goal) return node;    for (const next of graph[node]) {      if (!visited.has(next)) {        visited.add(next); queue.push(next);      }    }  }  return null;}