web-dev-qa-db-fra.com

Parcourant tous les nœuds d'un arbre binaire dans Java

Disons que j'ai une classe de nœud d'arbre binaire simple, comme ceci:

public class BinaryTreeNode {
    public String identifier = "";
    public BinaryTreeNode parent = null;
    public BinaryTreeNode left = null;
    public BinaryTreeNode right = null;

    public BinaryTreeNode(BinaryTreeNode parent, String identifier)
    {
        this.parent = parent; //passing null makes this the root node
        this.identifier = identifier;
    }

    public boolean IsRoot() {
        return parent == null;
    }
}

Comment ajouter une méthode capable de parcourir récursivement n'importe quelle taille d'arbre, en visitant chaque nœud existant de gauche à droite, sans revisitant un nœud qui a déjà été traversé?

Est-ce que cela fonctionnerait?:

public void traverseFrom(BinaryTreeNode rootNode)
{
    /* insert code dealing with this node here */

    if(rootNode.left != null)
        rootNode.left.traverseFrom(rootNode.left);

    if(rootNode.right != null)
        rootNode.traverseFrom(rootNode.right);
}
javabinary-treetraversaltree-traversal
15
RectangleEquals

Il existe 3 types de traversée d'arbre binaire que vous pouvez réaliser:

exemple:

considérez cet arbre binaire suivant:

enter image description here

Pre-order traversal sequence: F, B, A, D, C, E, G, I, H (root, left, right)
In-order traversal sequence: A, B, C, D, E, F, G, H ,I (left, root, right)
Post-order traversal sequence: A, C, E, D, B, H, I, G, F (left, right, root)

exemple de code:

traversée de gauche à droite de l'arbre binaire, non Dans l'ordre Traversée de l'arbre binaire:

public void traverse (Node root){ // Each child of a tree is a root of its subtree.
    if (root.left != null){
        traverse (root.left);
    }
    System.out.println(root.data);
    if (root.right != null){
        traverse (root.right);
    }
}
33
codeMan

codeMan a raison. La traversée visitera chaque nœud à gauche. Une fois qu'il atteint le dernier nœud à gauche, il commence à remonter le long des nœuds de droite. Il s'agit d'une traversée de recherche en profondeur (DFS). En tant que tel, chaque nœud n'est visité qu'une seule fois, et l'algorithme s'exécute en O(n) temps. Bon codage.

8
RouteMapper