Les arbres binaires - Tracing via le code

Question

Les arbres binaires - Tracing via le code

voix

0

Compte tenu de l'arbre binaire illustré ci - dessous, déterminer l'ordre dans lequel les noeuds de l'arbre binaire indiqué ci - dessous sont visités en supposant que la fonction A (racine) est invoquée. On suppose que les nœuds de l' arbre et des pointeurs sont définis comme indiqué. On suppose que la racine est un pointeur sur le nœud contenant 60. Ma réponse à ce problème est donnée ci - dessous. Est-ce correct? Qu'ai-je fait de mal?

                                   60
                                 /    \
                                30     90
                               /  \   / 
                              5   38  77
                               \  /  / \
                               8 32 62  88



struct treeNode{
  int data;
  struct treeNode *left, *right:
  {

struct treeNode *tree_ptr;

void A(struct treeNode *node_ptr){
    if (node_ptr != NULL){
    printf(“%d ,”,node_ptr->data);
    B(node_ptr->left);
    B(node_ptr->right);
   }   
}

void B(struct treeNode *node_ptr){
    if (node_ptr != NULL) {
    A(node_ptr->left);
    printf(“%d ,”,node_ptr->data);
    A(node_ptr->right);
   }
 }

Réponse: Dans A vide , il dit à la première impression node_ptr-> données si 60 est imprimé Ensuite , la fonction appelle B (node_ptr-> gauche) puis au sein de B, A est appelé (node_ptr-> gauche) , puis l' impression que les données qui est 5 . Et puis A (node_ptr-> droite) est appelé Remontons à A, l' impression que les données si 8 est imprimé. Maintenant , je ne suis pas sûr quoi faire , mais je reçois logiquement , il serait logique d'imprimer 30 , mais je ne suis pas sûr de savoir comment le PTR obtient de 8 à 30. Et si vous continuez dans le même modèle 38 est imprimé et 32 est imprimé. Pour le sous - arbre droit ... 90 77 62 88

c algorithm data-structures binary-search-tree

Créé 14/12/2010 à 22:05
source utilisateur kachilous

Dans d'autres langues...

4 réponses

voix

1

Pour commencer, votre code a un tas d'erreurs dans ce. Je suppose que ce devrait être plus comme ceci:

struct treeNode{
  int data;
  struct treeNode *left, *right;
}

treeNode *tree_ptr;

void A(treeNode *node_ptr){
    if (node_ptr != NULL){  /// this could be just if(node_ptr)
        printf(“%d ,”,node_ptr->data);
        B(node_ptr->left);
        B(node_ptr->right);
    }   
}

void B(treeNode *node_ptr){
    if (node_ptr != NULL) {
        A(node_ptr->left);
        printf(“%d ,”,node_ptr->data);
        A(node_ptr->right);
    }
}

Vous mélangez également deux algorithmes différents traversal. A()est pré-commande, B()est en ordre. A()et B()devraient s'appeler, pas. (Encore une autre raison d'utiliser vrai nom des variables / fonction au lieu de A, Bet par exemple.)

Créé 14/12/2010 à 22:11
source utilisateur Dav3

voix

1

Il suffit d'écrire la pile complète d'exécution au fil du temps. Comme ça:

A(60)
  printf
  B(30)
    A(5)
      ...
    printf
    A(38)
      ...
  B(90)
    ...

(Le reste de l'arbre laissé en exercice au lecteur.)

Ensuite, il suffit aller de haut en bas, écrire les résultats des relevés de printf.

Créé 14/12/2010 à 22:14
source utilisateur jdmichal

voix

1

la trace comme indiqué ci-dessus ne peut être correct pour une ou l'autre pré-ordre ou dans l'ordre pré - 60, 30, 5, 8 35 32 etc In - 5, 8, 30, 32, 35 etc.

Créé 28/03/2011 à 09:59
source utilisateur Brian

Vivin Paliath · Accepted Answer · 2010-12-14 22:15

Aest un parcours de pré-commande, alors que Best un ordre dans la traversée.

Un moyen facile pour vous de comprendre l'ordre d'impression est de regarder comment vous visitez les nœuds eux - mêmes. Je dessine habituellement un contour autour de l'extérieur de l'arbre ( à partir de la racine et se déplaçant à travers la gauche ou à droite en fonction du sous-arbre vous premier déplacement). Si je fais un traversal pré-commande, imprimer un nœud à chaque fois que je me déplace le long de son extérieur . Si je fais un en ordre traversal, imprimer un nœud que lorsque je passe sous (cela est logique quand on regarde dans l'ordre traversals, parce que vous finissez par l' impression des feuilles d' abord, ils sont les premiers nœuds que vous déplacez sous lorsque vous dessinez le contour). Si je fais un traversal post-commande, imprimer un nœud que lorsque je déplace le long de son intérieur .

METTRE À JOUR

La raison pour laquelle 30 est imprimé après 5 et 8 est que vous n'êtes pas effectuez une traversal purement pré-commande. Vous sautez entre une précommande et un dans l'ordre traversal.

Un moyen facile de comprendre l'ordre est d'écrire en fait sur les marches de votre code passe par que vous tracez à travers elle (je l'utilise souvent un stylo / crayon et papier pour garder ensemble les informations). Par exemple, vous pouvez faire écrire un appel pile comme ceci:

A(60)
  printf(60)
  call B(60.left)
    B(30)
      call A(30.left)
        A(5)
          printf(5)
          call B(5.left)
            B(null)
          call B(5.right)
            B(8)
              call A(8.left)
                A(null)
              printf(8)
              call A(8.right)
                A(null)
      printf(30)
      call A(30.right)
        A(38)
        ...

Vous pouvez facilement voir l'ordre dans lequel les noeuds sont imprimés, et plus important encore, pourquoi vous « sauter » de l'impression 8 à 30 impression (un appel récursif est terminée et vous retombant d'un niveau).