web-dev-qa-db-fra.com

Largeur première recherche et profondeur première recherche

Quelqu'un peut-il donner un lien pour une explication simple sur BFS et DFS avec son implémentation?

algorithmsearch
23
Jony

Disons que vous avez la structure suivante:

 Format: Node [Enfants] 
 
 A [BCD] 
 B [EF] 
 C [G] 
 D [ ] 
 E [] 
 F [] 
 G []

Une première recherche approfondie visite tous les enfants d'un nœud avant de rendre visite à leurs enfants. Voici le pseudocode et la solution pour la structure ci-dessus:

1. Noeud racine en attente. 
 2. Dequeue et sortie. Si la file d'attente est vide, passez à l'étape 5. 
 3. Mettre en file d'attente les enfants du noeud retiré de la file d'attente. 
 4. Passez à l'étape 2. 
 5. Terminé

 Deux files d'attente: (Noeud actif) [Sortie] [Ensemble de travail] 
 Commençant par la racine: 
 () [] [A] 
 (A) [A ] [BCD] 
 (B) [AB] [CDEF] 
 (C) [ABC] [DEFG] 
 (D) [ABCD] [EFG] 
 (E) [ABCDE] [FG] 
 (F) [ABCDEF] [G] 
 (G) [ABCDEFG] [] 
 
 Fait le

Une recherche d'abord en profondeur vise plutôt le niveau le plus bas (enfants les plus profonds) de l'arbre. Il existe deux types de première recherche de profondeur: pré-commande et post-commande. Cela ne fait que distinguer le moment où vous ajoutez le nœud à la sortie (lorsque vous le visitez ou le laissez).

 var rootNode = structure.getRoot (); 
 var preOrder = new Array (); 
 var postOrder = new Array (); 
 fonction DepthFirst (rootNode) {
 // Précommande 
 PreOrder [preOrder.length] = rootNode; 
 
 Pour (var enfant dans rootNode) {
 DepthFirst ( enfant); 
} 
 
 // Post-order 
 postOrder [postOrder.length] = rootNode; 
} 

 Précommande: 
 * A B E F C G D 
 
 Après commande: 
 * E F B G C D A
26
apandit

Première recherche en profondeur:

alt text

35
claws

Disons que vous avez un arbre comme suit:

alt text http://i40.tinypic.com/289aslh.jpg

Cela peut paraître un peu déroutant, car E est à la fois un enfant de A et de F, mais cela permet d’illustrer la profondeur lors d’une première recherche en profondeur. Une première recherche de profondeur cherche dans l’arbre aussi profond que possible (d’où le terme profondeur). Donc, le parcours de gauche à droite serait A, B, D, F, E, C, G.

Une première recherche approfondie évalue d'abord tous les enfants avant de passer aux enfants des enfants. Donc, le même arbre irait A, B, C, E, D, F, G.

J'espère que cela t'aides.

7
Ternary

vous pouvez trouver tout sur wiki:

BFS et DFS

ceci link peut être utile aussi. si vous voulez une implémentation, allez à: c ++ boost library: DFS

5
sorush-r

Voici quelques liens à consulter:

BFS est une méthode de recherche non informée qui vise à développer et à examiner tous les nœuds d’un graphe ou d’une combinaison de séquences en effectuant une recherche systématique dans toutes les solutions. En d’autres termes, il recherche de manière exhaustive dans l’ensemble du graphique ou de la séquence sans tenir compte de l’objectif jusqu’à ce qu’il le trouve.

Formellement, DFS est une recherche non informée qui progresse en développant le premier nœud enfant de l’arborescence de recherche qui apparaît et s’approfondit ainsi jusqu’à ce qu’un nœud d’objectif soit trouvé ou jusqu’à atteindre un nœud sans enfants. Puis la recherche revient en arrière et revient au noeud le plus récent qu'elle n'a pas encore exploré.

Ils contiennent non seulement de bonnes explications sur la manière dont ils sont implémentés dans les applications, mais également un pseudo-code d'algorithme.

3
Anthony Forloney

Largeur première recherche/Profondeur première recherche Animations

2
Pratik Deoghare

extrait avec 2 pointeurs.

void BFS(int v,struct Node **p)
{
     struct Node *u;

     visited[v-1] = TRUE;
     printf("%d\t",v);
     AddQueue(v);

     while(IsEmpty() == FALSE)
     {
         v = DeleteQueue();
         u = *(p+v-1);

         while(u!=NULL)
         {
            if(visited(u->data -1) == FALSE)
            {
                  AddQueue(u->data);
                  visited[u->data -1]=TRUE;
                  printf("%d\t",u->data);
            }

            u = u->next;
         }
     }
}
1
Muzab

Voici l’idée de base:

obtenez une nouvelle file d'attente ... initialisez-la avec le nœud racine ... parcourez toute la file d'attente et continuez à retirer un élément de la file d'attente et à l'imprimer (ou l'enregistrer, etc.) et vérifiez si le même élément a des enfants si c'est le cas Poussez-les dans la file d'attente et continuez dans la boucle jusqu'à parcourir l'intégralité du segment (graphique) ...

1
j2emanue

traversée de graphique avec dfs et bfs.

dans c ++ et python .

1
Yin Zhu

Tout d'abord, BFS et DFS sont deux moyens d'implémenter la traversée d'arbres binaires. Largeur d'abord signifie traversée de niveau. Depth First a trois façons d'implémenter -,.

Pré-commander:

a. Start with root,
b. mark it visited,
c. go to left node
d. (b) - mark it visited
e. Repeat (c) till there is not any new left node remaining
 (We are/might be at leaf node at this point,)
f. Is there any right node available? If yes, go to (a).

Niveau Ordre Traversée Temps Complexité Temps (n) - Le nombre de fois que chaque nœud est visité est 1, signifie que le total est n fois.

Complexité de l'espace - Meilleur cas: l'arborescence ne contient que des nœuds, O(1) Cas moyen: l'arborescence binaire parfaite est un exemple, n/2 nombre de nœuds, O (n)

0
hi.nitish

BFS et DFS sont applicables à tous les types de graphiques. Je l'explique uniquement pour l'arbre binaire. BFS visite chaque nœud de haut en bas, de gauche à droite. Par exemple pour cela:

       1
      / \
     7   9
     \  / \
      8 2 3

BFS nous donne: 1 7 9 8 2 3. DFS visite d'abord la profondeur de chaque branche. Ensuite, il revient à ses parents. Vous pouvez suivre cette règle informelle. D'abord quitté l'enfant, puis l'enfant droit, puis le parent. Mais vous devez commencer par la profondeur de chaque branche. Par exemple, ici, vous partez de 8, puisqu’il n’ya plus d’enfant pour 7 ans. Ensuite, vous rendez visite au parent 7. Ensuite, 1 parent sur 7 sera visité. Ensuite, vous allez à la branche droite. Mais, cette fois, il y a 2 comme enfant le plus à gauche. Donc, vous rendez visite à 2 (enfant de gauche), puis à droite, puis à leurs enfants. Donc, DFS nous donne 8 7 1 2 9 3. Ceci est la mise en œuvre:

import Java.util.ArrayList;
import Java.util.List;

public class TreeTraverse {

    static class Node{
        Node(int data){
            this.data = data;
            this.left = null;
            this.right = null;
            this.visited = false;
        }
        int data;
        Node left;
        Node right;
        boolean visited;
    }

    public static void main(String[] args) {
        //The tree:
        //   1
        //  / \
        // 7   9
        // \  / \
        //  8 2 3

        Node node1 = new Node(1);
        Node node7 = new Node(7);
        Node node9 = new Node(9);
        Node node8 = new Node(8);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        node1.left = node7;
        node1.right = node9;
        node7.right = node8;
        node9.right = node3;
        node9.left = node2;
        System.out.println("DFS: ");
        depthFirstSearch(node1);
        System.out.println("\nBFS: ");
        breadthFirstSearch(node1);

    }

    private static void depthFirstSearch(Node node){
        if(node.left == null && node.right == null){
            System.out.print(node.data+" ");
            node.visited = true;
        }else if(node.left == null || node.left.visited){
            depthFirstSearch(node.right);
            System.out.print(node.data+" ");
            node.visited = true;
        }else{
            depthFirstSearch(node.left);
            node.visited = true;
            System.out.print(node.data+" ");
            depthFirstSearch(node.right);

        }
    }

    private static void breadthFirstSearch(Node node){
        List<Node> al = new ArrayList<>();
        al.add(node);
        while(!al.isEmpty()){
            node = al.get(0);
            if(node.left != null){
                int index = al.size();
                al.add(index,node.left);
            }
            if(node.right != null){
                int index = al.size();
                al.add(index,node.right);
            }
            System.out.print(al.get(0).data+" ");
            al.remove(0);


        }
    }

}

J'espère que ça aide. Si vous souhaitez cloner le projet, rendez-vous sur: https://github.com/m-vahidalizadeh/foundations/blob/master/src/algorithms/TreeTraverse.Java . J'espère que ça aide.

0
Vahid