algorithmes BFS et DFS

#include <vector> 
#include <iostream> 
#include <stack> 
#include <file>
 en utilisant l'  espace de noms std; 

struct BitNode 
{ 
    int données; 
    BitNode * gauche, * droit; 
    BitNode ( int x): données (x), à gauche ( 0 ), à droite ( 0 ) {} 
}; 

annuler Créer (BitNode * & root) 
{ 
    int clé; 
    cin >> clé;
    si (clé == - 1 ) 
        root = NULL;
    autre
    { 
        La racine = new new BitNode (Key), 
        la Création (la racine -> gauche); 
        Créer (la racine -> droite); 
    } 
} 

vide PreOrderTraversal (BitNode * la racine) 
{ 
    IF (la racine) 
    { 
        COUT << répertoire root-> << Données "  " ; 
        PreOrderTraversal (racine -> gauche); 
        PreOrderTraversal (racine -> droite); 
    } 
} 

// profondeur première recherche
 // utiliser la pile, va maintenant pousser le sous - arbre à droite, puis pousser le sous - arbre gauche 
vide algorithme de parcours en profondeur (BitNode *root) 
{ 
    pile <BitNode *> nodeStack; 
    nodeStack.push (racine); 
    tandis que (! nodeStack.empty ()) 
    { 
        BitNode * noeud = nodeStack.top (); 
        Cout << node-> << données '  ' ; 
        nodeStack.pop (); 
        si (node-> droite) 
        { 
            nodeStack.push (noeud -> à droite); 
        } 
        Si (node-> gauche) 
        { 
            nodeStack.push (noeud -> gauche); 
        } 
    } 
} 

//广度优先搜索
vide algorithme de parcours en largeur (BitNode * root) 
{ 
    file d' attente <BitNode *> nodequeue; 
    nodeQueue.push (racine); 
    tandis que (! nodeQueue.empty ()) 
    { 
        BitNode * noeud = nodeQueue.front (); 
        Cout << node-> << données '  ' ; 
        nodeQueue.pop (); 
        si (node-> gauche) 
        { 
            nodeQueue.push (noeud -> gauche); 
        } 
        Si (node-> droite) 
        { 
            nodeQueue.push (noeud -> à droite);
        } 
    } 
} 

Int   principal () 
{ 
    BitNode * root = NULL; 
    Créer (la racine); 
    // précommande traversal 
    PreOrderTraversal (la racine);
     // profondeur premier traversal 
    Cout << endl << " DFS " << endl; 
    algorithme de parcours en profondeur (la racine ); 
    // en largeur recherche 
    cout << << Endl " BFS " << endl; 
    algorithme de parcours en largeur (racine); 
}

 

 

BFS: largeur-premier algorithme, à travers la file d'attente, l'équipe sous-arbre gauche, à droite dans l'subtree équipe.

DFS: profondeur d'abord algorithme, pile, empiler le sous-arbre droit, gauche pile de sous-arbre.