arbre binaire -print les éléments en fonction du niveau

Le traversal dans votre question est appelé level-order traversalet c'est la façon dont il est fait (extrait de code très simple , / j'ai trouvé propre).

Vous utilisez essentiellement une file d'attente et l'ordre des opérations ressemblera à quelque chose comme ceci:

enqueue F
dequeue F
enqueue B G
dequeue B
enqueue A D
dequeue G
enqueue I
dequeue A
dequeue D
enqueue C E
dequeue I
enqueue H
dequeue C
dequeue E
dequeue H

Pour cet arbre (de Wikipedia droite):

Le terme qui est le niveau d'ordre traversal . Wikipedia décrit un algorithme pour qu'utiliser une file d' attente :

levelorder(root) 
  q = empty queue
  q.enqueue(root)
  while not q.empty do
    node := q.dequeue()
    visit(node)
    if node.left ≠ null
      q.enqueue(node.left)
    if node.right ≠ null
      q.enqueue(node.right)

BFS :

std::queue<Node const *> q;
q.push(&root);
while (!q.empty()) {
    Node const *n = q.front();
    q.pop();
    std::cout << n->data << std::endl;
    if (n->left)
        q.push(n->left);
    if (n->right)
        q.push(n->right);
}

Itératives approfondissement collaborerait également et enregistre l'utilisation de la mémoire, mais au détriment du temps de calcul.

J'utiliser une collection, par exemple std::list, pour stocker tous les éléments du niveau en cours d' impression:

1. Recueillir des pointeurs vers tous les nœuds du niveau actuel dans le conteneur
2. Imprimer les noeuds répertoriés dans le conteneur
3. Faire un nouveau conteneur, ajoutez les sous-noeuds de tous les noeuds dans le conteneur
4. Ecraser l'ancien conteneur avec le nouveau conteneur
5. répéter jusqu'à ce que le contenant est vide

comme un exemple de ce que vous pouvez faire à une entrevue si vous ne vous souvenez pas / ne connaissent pas l'algorithme « officiel », ma première idée était - traverse l'arbre dans le pré-ordre régulier faisant glisser un compteur de niveau le long, le maintien d'un vecteur des listes liées de pointeurs vers des noeuds par niveau, par exemple

levels[level].push_back(&node);

et à la fin imprimer la liste de chaque niveau.

Si nous sommes en mesure d'aller chercher l'élément suivant au même niveau, nous fait. Selon notre connaissance préalable , nous pouvons accéder à ces éléments en utilisant la largeur première traversal.

Maintenant, seul problème est de savoir comment vérifier si nous sommes le dernier élément à tout niveau. Pour cette raison, nous devrions être l'ajout d'un séparateur (NULL dans ce cas) pour marquer la fin d'un niveau.

Algorithme: 1. Mettez racine dans la file d' attente.
2. NULL Mettre en file d' attente.
3. Alors que la file d' attente ne soit pas vide
4. x = chercher premier élément de file d' attente
5. Si x est NULL
6. X-> rpeer <= élément supérieur de la file d' attente.
7. mettre l' enfant à gauche et à droite de x dans la file d' attente
8. autre
9. si la file d' attente n'est pas vide
10. NULL mettre en file d' attente
11. fin si
12. fin en
13. retour

#include <queue>

void print(tree* root)
{
  queue<tree*> que;
  if (!root)
      return;

  tree *tmp, *l, *r;
  que.push(root);
  que.push(NULL);

  while( !que.empty() )
  {
      tmp = que.front();
      que.pop();
      if(tmp != NULL)
      {
          cout << tmp=>val;  //print value
          l = tmp->left;
          r = tmp->right;
          if(l) que.push(l);
          if(r) que.push(r);
      }
      else
      {
          if (!que.empty())
              que.push(NULL);
      }
  }
  return;
}