Une traversée d'arbre fait référence à l'accès à chaque n?ud de l'arbre une fois et une seule fois dans un ordre spécifique. 1. Accédez d'abord au n?ud racine, puis traversez les sous-arbres gauche et droit; 2. D'abord l'accès du sous-arbre gauche dans l'ordre moyen traverse la gauche puis traverse le sous-arbre droit; 3. D'abord l'accès aux sous-arbres gauche et droit dans le second ordre traverse les sous-arbres gauche et droit dans le dernier ordre traversent le n?ud racine. En Java, il peut être implémenté via Recursion ou Stack, où la méthode de récursivité est claire, plut?t que la mise en ?uvre récursive, il nécessite que la pile simule le processus d'appel pour éviter le débordement de la pile. En termes de scénarios d'application, le prédécesseur est utilisé pour copier ou sérialiser l'arborescence, l'ordre moyen convient à la sortie ordonnée de l'arborescence de recherche binaire et le dernier ordre est utilisé pour supprimer l'arborescence ou l'évaluation de l'expression.

La mise en ?uvre de la traversée des arbres (préambule, milieu et post-séquence) en Java est l'un des contenus de base des structures de données d'apprentissage. Ces trois méthodes de traversée sont la traverse en profondeur d'abord, et leur différence de base réside dans les différents horaires de l'accès au n?ud racine.

Qu'est-ce que la traversée d'un arbre?

La traversée de l'arborescence fait référence à l'accès à chaque n?ud de l'arbre dans un certain ordre, garantissant que chaque n?ud est accessible une fois et une seule fois. Pour les arbres binaires, les trois fa?ons les plus courantes de traverser sont:

• Traversion de précommande : Accédez d'abord au n?ud racine, puis accédez récursivement au sous-arbre gauche à l'avance, et enfin accéder à la sous-arbre droit à l'avance.
• Traversion dans l'ordre : Tout d'abord, accédez à récursivement le sous-arbre gauche dans l'ordre moyen, puis accédez au n?ud racine et accédez enfin au sous-arbre droit dans l'ordre moyen.
• Traversion post-commande : d'abord, accédez à récursivement le sous-arbre gauche dans l'ordre, puis accédez au sous-arbre droit dans l'ordre, et enfin accéder au n?ud racine.

Comment définir un n?ud d'arbre binaire?

En Java, nous définissons généralement une classe qui représente un n?ud d'arbre binaire:

 classe Treenode {
    int Val;
    Treenode à gauche;
    Treenode à droite;

    Treenode (int Val) {
        this.val = val;
    }
}

Cette classe est très basique, mais est suffisante pour soutenir les opérations de traverse ultérieures.

écriture récursive de la précommande, de l'ordre moyen et de la traversée post-ordre

La récursivité est la plus intuitive et la plus facile à comprendre. Voici les implémentations de base de chaque méthode de traversée:

Exemple de traversée de préambule:

 vide précommande (root Treenode) {
    if (root == null) return;
    System.out.print (root.val ""); // accéder à la précommande du n?ud racine (root.left); // traverse la précommande du sous-arbre gauche (root.right); // traverse le sous-arbre droit}

Exemple de traversée dans l'ordre:

 void inOrder (Treenode Root) {
    if (root == null) return;
    inordre (root.left);
    System.out.print (root.val "");
    inOrder (root.Right);
}

Exemple de traversée post-ordre:

 VOID Postorder (Treenode Root) {
    if (root == null) return;
    post-ordre (root.left);
    post-ordre (root.Right);
    System.out.print (root.val "");
}

Ces méthodes sont claires dans la logique et la concise dans le code, ce qui convient aux débutants pour comprendre et utiliser.

à quoi dois-je prêter attention lors de la mise en ?uvre de non-cernes?

Bien que la récursivité soit simple à mettre en ?uvre, il est parfois nécessaire d'éviter d'utiliser la récursivité dans le développement réel, comme le débordement de la pile lorsque la profondeur de la pile est trop grande. Pour le moment, vous pouvez utiliser une pile pour simuler le processus récursif.

Prenant l'exemple de la traversée dans l'ordre dans l'ordre, la mise en ?uvre non réécursive est la suivante:

 void inORDERIRETRATIVE (root Treenode) {
    Stack <rerenode> pile = new Stack <> ();
    Treenode Current = root;

    while (current! = null ||! stack.isempty ()) {
        // pousse d&#39;abord tous les n?uds gauchers dans la pile tandis que (courant! = Null) {
            stack.push (courant);
            courant = courant.left;
        }

        courant = stack.pop ();
        System.out.print (Current.Val "");
        courant = courant.Right;
    }
}

Les points clés de cette approche sont:

• Utilisez while au lieu d'appels récursifs;
• Distinguer clairement le moment des "n?uds d'accès" et des "n?uds de processus";
• Faites attention au jugement des pointeurs nuls pour éviter les erreurs d'exécution.

Les deux autres traversées peuvent également être implémentées de manière similaire, mais la logique est un peu plus compliquée.

Quelles sont les différences dans les scénarios d'application?

Bien que ces trois méthodes de traversée soient similaires en structure, leurs scénarios d'application sont légèrement différents:

• Traversion précommande : souvent utilisée pour copier les structures des arbres ou sérialiser les arbres;
• Traversion dans l'ordre : S'il s'agit d'un arbre de recherche binaire (BST), la traversée dans l'ordre sortira une séquence ordonnée;
• Traversion post-ordre : Convient à des scénarios tels que la suppression des arbres entiers ou l'évaluation des expressions.

Par exemple, si vous avez un BST qui souhaite imprimer tous les éléments dans l'ordre croissant, la traversée d'ordre moyen est la plus appropriée.

Fondamentalement, c'est tout. La ma?trise de ces méthodes de traversée n'est pas seulement utile pour comprendre la structure des arbres, mais aussi la base de nombreux problèmes d'algorithmes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!