Étendue de la recherche de recherche en javascript

Dans ce monde technologique moderne, nous devons utiliser des techniques pour parcourir les arbres par programme, même si notre ordinateur a une interface conviviale pour parcourir notre arborescence de fichiers, à cet effet, la recherche en première large (BFS) est l'algorithme le plus utile.

Recherche de largeur est un traversant algorithme qui est utilisé pour rechercher ou traverser les données de l'arborescence ou du graphique Couche de structure par couche. Avant de passer au nœud des enfants du niveau de profondeur suivant, il visite chaque nœud qui existe à la profondeur actuelle.

Cet article expliquera comment exécuter le Algorithme de recherche en largeur en utilisant un exemple approprié. Alors, commençons

Comment fonctionne l'algorithme de recherche de l'étendue en javascript

Le fonctionnement de l'algorithme de recherche de l'étendue comprend les étapes suivantes:

• Choisir un nœud et créez un file d'attente avec tout son voisin nœuds.
• Retirer ceux nœuds de la file d'attente qui sont visitées et les marquent.
• Ajouter Tout son Nœuds voisins dans la file d'attente.
• Répéter Jusqu'à ce que la file d'attente devienne vide ou vous atteignez votre objectif.

Si un nœud est revisité avant qu'il ne soit pas marqué comme visité, le programme sera arrêté. Par conséquent, marquez les nœuds visités et ensuite il ne sera plus fouillé.

Implémentation de l'étendue première algorithme de traversée de recherche

Recherche de largeur Traverse les arbres de gauche à droite, puis se déplace de haut en bas (Nœud parent au nœud enfant). S'assurer que tous les nœuds présents sur la profondeur actuelle sont visités.

Maintenant, jetons un coup d'œil à un petit exemple pour comprendre le BFS Travaux de traversée. Ici, le graphique non dirigé donné a 5 nœuds «0», «1», «2», «3» et «4»:

Nous allons maintenant utiliser cet algorithme de traversée sur le graphique spécifié.

Étape 1: initialisation de la file d'attente

Tout d'abord, nous devons Initialiser la file d'attente "Q":

Étape 2: Choisissez le nœud de démarrage

Ensuite, nous choisirons le nœud de départ. À cette fin, nous sélectionnerons "0" comme nœud de départ et Marquez-le comme visité:

Étape 3: nœuds adjacents non visités du nœud de départ

Le nœud de départ est visité et marqué; Maintenant, nous allons vérifier son nœuds adjacents. Dans l'illustration ci-dessous, Node de départ "0" a Trois nœuds adjacents non visités «1», «2» et «3»; Cependant, nous choisirons le nœud "1" en raison de l séquence de comptage. Alors, marquer c'est comme a visité et ajouter il au file d'attente:

Maintenant le non visité nœud de «0» est «2», qui est aussi marqué comme visité et ajouté à la file d'attente:

Ensuite, nous allons visite le dernier nœud adjacent non visité, qui est "3", marqué comme visiter et l'obtenir:

Étape 4: Déqueue le nœud de départ

Maintenant notre nœud de départ sélectionné "0" n'a pas de nœuds adjacents non visités, nous supprimerons donc la file d'attente et rechercherons le nœud "1":

Étape 5: Vérifiez l'adjacent non visité du nœud «1»

À ce stade, nœud "1" avoir le nœud "4" comme son adjacent non visité:

Nœud "4" est maintenant marqué comme visité et ajouté à la file d'attente. Maintenant, nous n'avons plus nœuds non visités. Cependant, selon le algorithme, Nous obtiendrons tout nœuds non visités et continuer à retirer le nœud de la file d'attente selon la procédure. Le programme se terminera lorsque la file d'attente deviendra vide.

Implémentez un exemple pour vérifier comment fonctionne la recherche en largeur Javascrip.

Comment implémenter une largeur de recherche en largeur de largeur en JavaScript

Pour implémenter la traversée de recherche de largeur de largeur en JavaScript, nous allons d'abord créer un graphique:

Laissez graphique;

Le graphique ci-dessus qui est utilisé pour illustrer la recherche d'étendue première "5" nœuds. Alors, ici nous définirons "5" NODES:

constants nœuds = 5;

Maintenant, créez un «Visité []» Array qui sera utilisé pour stocker nœuds visités et le longueur de ce tableau sera défini en fonction du nombre de nœuds:

Soit visiter = nouveau tableau (nœuds);

Ensuite, nous définirons le "CreateGraph ()" fonction dans le but de créer un graphique et d'y ajouter des nœuds. Puis le "pour" Loop s'exécutera jusqu'à la longueur du graphique. À l'intérieur de la boucle, il y a un tableau bidimensionnel qui est utilisé pour représenter les bords graphiques initialisés avec "0":

const Creategraph = (nœuds) =>
graph = nouveau tableau (nœuds);
pour (soit i = 0; i < graph.length; i++)
graphique [i] = nouveau tableau (nœuds);
pour (laissez i = 0; i < graph.length; i++)
pour (que j = 0; j < graph[i].length; j++)
graphique [i] [j] = 0;


;

Ensuite, nous définirons le "Addge ()" fonction qui accepte deux arguments «A» et «B». Cette fonction vérifiera le bord entre deux nœuds. Si un bord se trouve entre deux nœuds, alors le Fonction "Addge ()" remplacera le Entrée "0" avec "1" dans le graphique créé (tableau bidimensionnel). Aussi, ajoutant "1" indique que l'argument des nœuds passés a un avantage entre eux:

const Addge = (a, b) =>
pour (soit i = 0; i < graph.length; i++)
pour (que j = 0; j < graph[i].length; j++)
if (i === a && j === b)
graphique [i] [j] = 1;
graphique [j] [i] = 1;

Maintenant, nous allons définir le "EamplethFirstSearch ()" fonction. Tout d'abord, nous créerons un vide "file d'attente". Au début, tous les nœuds ne sont pas visités afin qu'ils soient marqués comme faux avec un "Visité [i] = false" déclaration. Ensuite, nous sélectionnerons le démarrage "nœud" qui est passé comme argument au "EamplethFirstSearch ()" fonction et marquez-le visité. Le "file d'attente.pousser()" la méthode poussera le "nœud" à la file d'attente puis le "alors que" la boucle s'exécutera jusqu'à la longueur de la file d'attente. Cette boucle vérifiera les bords du «Current Node» avec le nœud restant.

À l'intérieur de Boucle «pour», le ajouté «Si» Condition “[CurrentNode] [J] === 1” vérifiera les bords entre le «Current Node» Et le reste "J" nœuds. Dans le cas, si les deux nœuds ont un bord entre eux et le correspondant Node «J» n'est pas encore visité, alors il sera marqué comme «Visité» et poussé à la «file d'attente»:

const de largethfirstSearch = (node) =>
const queue = []; pour (soit i = 0; i < visited.length; i++)
visité [i] = false;
visité [node] = true;
file d'attente.push (nœud);
Pendant (file d'attente.longueur)
Laissez currentNode = file d'attente.changement();
console.log ('visiter $ currentNode');
pour (que j = 0; j < graph[currentNode].length; j++)
if (graph [currentNode] [j] === 1 && visité [j] === false)
visité [j] = true;
file d'attente.push (j);



;

Ensuite, nous appellerons le Fonction "CreateGraph ()" et passer le "Nœuds" comme argument:

CreateGraph (nœuds);

Après cela, spécifiez les bords du nœud «0, 1, 2, 3» avec le Fonction "Addge ()", Comme démontré dans le diagramme ci-dessus:

Addge (0, 1);
Addge (0, 2);
Addge (0, 3);
Addge (1, 0);
Addge (1, 4);
Addge (2, 0);
Addge (2, 4);
Addge (3, 0);
Addge (3, 4);

Ici, "0" est passé comme nœud de départ au Fonction BFS () qui effectuera l'exploitation supplémentaire:

EamplethFirstSearch (0);

Méthode BFS () Traversera les nœuds graphiques et sortira les nœuds visités sur la console:

C'était toutes des informations utiles sur Algorithme de traversée de recherche de largeur de largeur en javascript. Optez pour des recherches supplémentaires si nécessaire.

Conclusion

Étendue-première recherche (BFS) est un traversant algorithme qui est utilisé pour Recherche ou traverser la couche de structure de données d'arbre ou de graphique par calque. Avant de passer au nœud d'enfants du niveau de profondeur suivant, il visite chaque nœud qui existe au profondeur actuelle. Dans cet article, nous avons brièvement discuté de l'algorithme JavaScript de la traversée de recherche et de la recherche et son travail avec l'aide d'un exemple approprié.