Primeira busca pela largura Traversal em JavaScript

Neste mundo tecnológico moderno, somos obrigados a usar técnicas para atravessar as árvores programaticamente, mesmo que nosso computador tenha uma interface amigável para navegar em nossa árvore de arquivos, para esse fim, a primeira pesquisa de BFS) é o algoritmo mais útil.

Pesquisa pela primeira vez é um atravessando algoritmo que é usado para Pesquisando ou atravessando os dados da árvore ou gráfico camada de estrutura por camada. Antes de passar para o nó das crianças do próximo nível de profundidade, ele visita cada nó que existe na profundidade atual.

Este artigo explicará como executar o Algoritmo de pesquisa pela primeira vez usando um exemplo apropriado. Então vamos começar

Como funciona o algoritmo de pesquisa da amplitude em JavaScript

O funcionamento do algoritmo de pesquisa da amplitude compreende as seguintes etapas:

• Escolher um nó e criar um fila com todos os seus vizinho nós.
• Remover aqueles nós da fila que são visitadas e marque -os.
• Adicionar todos nós vizinhos na fila.
• Repita Até que a fila se torne vazio ou você atinge seu objetivo.

Se um nó for revisado antes de não ser marcado como visitado, o programa será interrompido. Portanto, marque os nós como visitados e depois não serão pesquisados ​​novamente.

Implementação do algoritmo atravessado pela primeira vez

Pesquisa pela primeira vez atravessa árvores da esquerda para a direita e depois se move de cima para baixo (Nó dos pais para o nó infantil). garantindo que todos os nós presentes na profundidade atual sejam visitados.

Agora, vamos dar uma olhada em um pequeno exemplo para entender o BFS Trabalhos de travessia. Aqui, o gráfico não direcionado dado tem 5 nós "0", "1", "2", "3" e "4":

Agora usaremos este algoritmo de travessia no gráfico especificado.

Etapa 1: Inicialização da fila

Primeiro de tudo, temos que Inicialize a fila "Q":

Etapa 2: Escolha o nó inicial

Em seguida, escolheremos o nó inicial. Para esse fim, vamos selecionar "0" como nó inicial e Marque como visitado:

Etapa 3: nós adjacentes não visitados do nó de partida

O nó inicial é visitado e marcado; Agora, vamos verificar seu nós adjacentes. Na ilustração abaixo, nó inicial "0" tem Três nós adjacentes não visitados “1”, “2” e “3”; No entanto, vamos escolher o nó "1" por causa do seqüência de contagem. Então, marca como visitado e adicionar para o fila:

Agora o não visitado nó de "0" é "2", Que tambem é Marcado como visitado e adicionado à fila:

Então nós vamos Visita o último nó adjacente não visitado, que é "3", marcou como visitou e onei:

Etapa 4: Dequeue o nó inicial

Agora nosso nó inicial selecionado "0" não possui nenhum nós adjacente não visitado, então removeremos a fila e procuraremos o nó "1":

Etapa 5: verifique o adjacente não visitado do nó “1”

Neste ponto, nó "1" tem nó "4" como seu adjacente não visitado:

Nó "4" agora está marcado como visitou e adicionado para a fila. Agora, não temos mais nós não visitados. No entanto, de acordo com o algoritmo, Vamos obter tudo nós não visitados e continue a remover o nó da fila conforme o procedimento. O programa terminará quando a fila se tornar vazio.

Vamos implementar um exemplo para verificar como a pesquisa de largura funciona JavaScript.

Como implementar a primeira busca de busca em JavaScript

Para implementar a primeira busca de pesquisa em JavaScript, antes de tudo, criaremos um gráfico:

deixe o gráfico;

O gráfico acima do rumo que é usado para ilustrar a primeira pesquisa tem "5" nós. Então, aqui vamos definir "5" nós:

const nós = 5;

Agora, crie um Array "visitou []" que será usado para armazenar nós visitados e a comprimento desta matriz será definida de acordo com o número de nós:

Seja visitado = nova matriz (nós);

Em seguida, definiremos o “CreateGraph ()” função com o objetivo de criar um gráfico e adicionar nós. Então o "para" O loop será executado até o comprimento do gráfico. Dentro do loop, há uma matriz bidimensional que é usada para representar as bordas do gráfico inicializadas com "0":

const CreateGraph = (nós) =>
gráfico = nova matriz (nós);
para (vamos i = 0; i < graph.length; i++)
Gráfico [i] = nova matriz (nós);
para (vamos i = 0; i < graph.length; i++)
para (vamos j = 0; j < graph[i].length; j++)
Gráfico [i] [j] = 0;


;

Então, vamos definir o “Adicionado ()” função que aceita dois argumentos "A" e "B". Esta função verificará a borda entre dois nós. Se uma vantagem é encontrada entre dois nós, então o Função “Adicionada ()” substituirá o “0” entrada com “1” No gráfico criado (matriz bidimensional). Além disso, adicionando "1" indica que o argumento dos nós passados ​​tem uma vantagem entre eles:

const Addedge = (a, b) =>
para (vamos i = 0; i < graph.length; i++)
para (vamos j = 0; j < graph[i].length; j++)
if (i === a && j === b)
Gráfico [i] [j] = 1;
gráfico [j] [i] = 1;

Agora, vamos definir o “LargthfirstSearch ()” função. Primeiro, vamos criar um vazio "fila". No início, todos os nós não são visitados para que sejam marcados como falsos com um “Visitado [i] = false” declaração. Então, vamos selecionar o início "nó" que é passado como argumento para o “LargthfirstSearch ()” função e marque visitou. O "fila.empurrar()" Método vai empurrar o "nó" para a fila então o "enquanto" O loop será executado até o comprimento da fila. Este loop verificará as bordas do “CurrentNode” com o nó restante.

Dentro de “Para” Loop, o adicionado Condição “Se” “[CurrentNode] [J] === 1” verificará as bordas entre o “CurrentNode” e o restante "J" nós. No caso, se ambos os nós tiverem uma vantagem entre eles e os correspondentes "J" Nó ainda não foi visitado, então será marcado como "Visitado" e empurrado para a "fila":

const larguthfirstSearch = (nó) =>
const fileue = []; para (vamos i = 0; i < visited.length; i++)
visitado [i] = false;
visitado [node] = true;
fila.push (nó);
enquanto (fila.comprimento)
Deixe CurrentNode = fila.mudança();
console.log ('visitando $ currentNode');
para (vamos j = 0; j < graph[currentNode].length; j++)
if (gráfico [currentNode] [j] === 1 && visitou [j] === false)
visitado [j] = true;
fila.push (j);



;

Em seguida, chamaremos o Função “creategraph ()” e passar o "Nós" como argumento:

CreateGraph (nós);

Depois de fazer isso, especifique as bordas do nó “0, 1, 2, 3” com o Função “Adicionada ()”, Conforme demonstrado no diagrama acima:

Adicionado (0, 1);
Adicionado (0, 2);
Adicionado (0, 3);
adicionado (1, 0);
adicionado (1, 4);
Adicionado (2, 0);
adicionado (2, 4);
Adicionado (3, 0);
adicionado (3, 4);

Aqui, "0" é passado como nó de partida para o Função bfs () que executará a operação adicional:

larguthfirstSearch (0);

Método BFS () atravessará os nós do gráfico e produzirá os nós visitados no console:

Isso foi tudo informações úteis sobre Algoritmo de travessia de pesquisa pela primeira vez em javascript. Escolha mais pesquisas, se necessário.

Conclusão

Pesquisa em largura (BFS) é um atravessando algoritmo que é usado para Pesquisando ou atravessando a camada da estrutura de dados da árvore ou gráfico por camada. Antes de passar para o Nó das crianças do próximo nível de profundidade, ele visita cada nó que existe no profundidade atual. Neste artigo, discutimos brevemente o algoritmo JavaScript atravesso pela primeira vez e seu trabalho com a ajuda de um exemplo adequado.