Amplth-First Search Traversal en JavaScript

En este mundo tecnológico moderno, estamos obligados a usar técnicas para atravesar los árboles programáticamente, a pesar de que nuestra computadora tiene una interfaz fácil de usar para navegar en nuestro árbol de archivos, para este propósito, la primera búsqueda (BFS) es el algoritmo más útil.

Búsqueda de la primera es un recorrido algoritmo que se usa para Buscar o atravesar los datos del árbol o gráfico Capa de estructura por capa. Antes de pasar al nodo infantil del siguiente nivel de profundidad, visita cada nodo que existe a la profundidad actual.

Este artículo explicará cómo ejecutar el Algoritmo de búsqueda de amplitud Usando un ejemplo apropiado. Entonces, comencemos

Cómo funciona el algoritmo de búsqueda de la amplitud en JavaScript

El funcionamiento del algoritmo de búsqueda de amplitud comprende los siguientes pasos:

• Elegir un nodo y crear un cola con todo su vecino nodos.
• Eliminar aquellos nodos de la cola que se visitan y marqué.
• Agregar todo su nodos vecinos en la cola.
• Repetir Hasta que la cola se vuelva vacío o llegaste a tu objetivo.

Si se revisa un nodo antes de no ser marcado como se lo visite, entonces el programa se detendrá. Por lo tanto, Mark Nodos como se visitan y luego no se volverá a buscar.

Implementación del algoritmo de transversal de búsqueda de amplitud

Búsqueda de la primera atraviesa árboles de izquierda a derecha, luego se mueve de arriba a abajo (nodo principal al nodo infantil). Asegurar que se visiten todos los nodos que están presentes en la profundidad de corriente.

Ahora, echemos un vistazo a un pequeño ejemplo para comprender el Bfs Trabajos de traversal. Aquí, el gráfico no dirigido dado tiene 5 nodos "0", "1", "2", "3" y "4":

Ahora usaremos este algoritmo de recorrido en el gráfico especificado.

Paso 1: Inicialización de la cola

En primer lugar, tenemos que Inicializar la cola "Q":

Paso 2: Elija el nodo inicial

A continuación, elegiremos el nodo inicial. Para este propósito, seleccionaremos "0" como nodo inicial y marque como se ve:

Paso 3: nodos adyacentes no visitados del nodo inicial

El nodo inicial es visitado y marcado; Ahora, comprobaremos su nodos adyacentes. En la siguiente ilustración, nodo inicial "0" tiene Tres nodos adyacentes no visitados "1", "2" y "3"; Sin embargo, elegiremos nodo "1" por el secuencia de contar. Entonces, marca como visitado y agregar es al cola:

Ahora el no visitado nodo de "0" es "2", cual es también marcado según lo visitado y agregado a la cola:

Luego lo haremos visita el último nodo adyacente no visitado, que es "3", lo marcó como Visitado y enoó:

Paso 4: Dequeue el nodo inicial

Ahora nuestro nodo inicial seleccionado "0" no tiene nodos adyacentes no visitados, por lo que eliminaremos la cola y buscaremos el nodo "1":

Paso 5: Verifique el adyacente no visitado del nodo "1"

En este punto, nodo "1" tener nodo "4" Como su adyacente no visitado:

Nodo "4" ahora está marcado como visitado y agregado a la cola. Ahora no tenemos más nodos no visitados. Sin embargo, según el algoritmo, Obtendremos todo nodos no visitados y continúe retirando el nodo de la cola según el procedimiento. El programa terminará cuando la cola se convierta en vacío.

Implementemos un ejemplo para verificar cómo funciona la búsqueda de amplitud Javascript.

Cómo implementar la primera transferencia de búsqueda en JavaScript en JavaScript

Para implementar la amplitud de la búsqueda de la búsqueda en JavaScript, en primer lugar, crearemos un gráfico:

dejar gráfico;

El gráfico dado anteriormente que se utiliza para ilustrar la búsqueda de amplitud "5" nodos. Entonces, aquí definiremos "5" Nodos:

nodos const = 5;

Ahora, crea un Array "Visited []" que se utilizará para almacenar nodos visitados y el longitud de esta matriz se establecerá de acuerdo con el número de nodos:

Let Visited = New Array (nodos);

A continuación, definiremos el "CreateGraph ()" función con el fin de crear un gráfico y agregar nodos a él. Entonces el "para" El bucle se ejecutará hasta la longitud del gráfico. Dentro del bucle, hay una matriz bidimensional que se usa para representar los bordes de gráficos inicializados con "0":

const creategraph = (nodos) =>
gráfico = nueva matriz (nodos);
para (deja i = 0; yo < graph.length; i++)
gráfico [i] = nueva matriz (nodos);
para (dejar i = 0; i < graph.length; i++)
para (dejar j = 0; j < graph[i].length; j++)
gráfico [i] [j] = 0;


;

Entonces, definiremos el "Se agregue ()" función que acepta dos argumentos "a y B". Esta función verificará el borde entre dos nodos. Si se encuentra un borde entre dos nodos, entonces el Función "Se agregue ()" reemplazará el Entrada "0" con "1" En el gráfico creado (matriz bidimensional). Además, agregando "1" Indica que el argumento de los nodos aprobados tiene una ventaja entre ellos:

const agregado = (a, b) =>
para (deja i = 0; yo < graph.length; i++)
para (dejar j = 0; j < graph[i].length; j++)
if (i === a && j === b)
gráfico [i] [j] = 1;
gráfico [j] [i] = 1;

Ahora, definiremos el "BreTthFirstSearch ()" función. Primero, crearemos un vacío "cola". Al principio, todos los nodos no están visitados, por lo que están marcados como falsos con un "Visitado [i] = falso" declaración. Entonces, seleccionaremos el inicio "nodo" que se pasa como argumento al "BreTthFirstSearch ()" función y marquelo visitando. El "cola.empujar()" El método empujará el "nodo" a la cola entonces el "mientras" El bucle se ejecutará hasta la longitud de la cola. Este bucle verificará los bordes del "CurrentNode" con el nodo restante.

Dentro de "en bucle, el agregado "If" condición "[CurrentNode] [j] === 1" Verificará los bordes entre el "CurrentNode" y el restante "J" nodos. En caso de que ambos nodos tengan un borde entre ellos y el correspondiente Nodo "J" aún no se visita, entonces se marcará como "Visitado" y empujado a la "cola":

const brechfirstsearch = (nodo) =>
const Queue = []; para (Sea i = 0; i < visited.length; i++)
visitado [i] = falso;
visitado [nodo] = true;
cola.Push (nodo);
mientras (cola.longitud)
Dejar que CurrentNode = cola.cambio();
consola.log ('visitar $ currentNode');
para (dejar j = 0; j < graph[currentNode].length; j++)
if (gráfico [currentNode] [j] === 1 && visited [j] === false)
visitado [j] = true;
cola.empuje (j);



;

A continuación, llamaremos al Función "CreateGraph ()" y pasar el "Nodos" como argumento:

CreateGraph (nodos);

Después de hacerlo, especifique los bordes del nodo "0, 1, 2, 3" con el Función "Se agregue ()", Como se demuestra en el diagrama anterior:

agregado (0, 1);
agregado (0, 2);
agregado (0, 3);
agregado (1, 0);
agregado (1, 4);
agregado (2, 0);
agregado (2, 4);
adicional (3, 0);
adicional (3, 4);

Aquí, "0" se pasa como nodo inicial al Función bfs () que realizará la operación adicional:

BreTthFirstSearch (0);

Método bfs () atravesará los nodos gráficos y emitirá los nodos visitados en la consola:

Esa fue toda información útil sobre Algoritmo de recorrido de búsqueda de amplitud en JavaScript. Vaya a investigar más si es necesario.

Conclusión

Búsqueda de amplitud (BFS) es un recorrido algoritmo que se usa para Buscar o atravesar la capa de estructura de datos de árbol o gráfico por capa. Antes de pasar a la nodo infantil del siguiente nivel de profundidad, visita cada nodo que existe en el profundidad de corriente. En este artículo, hemos discutido brevemente el algoritmo JavaScript de transversal de amplitud de amplitud y su trabajo con la ayuda de un ejemplo adecuado.