Construire une structure arborescente à partir de la liste des chemins de chaînes

J'ai une collection de string chemins comme ["x1/x2/x3","x1/x2/x4","x1/x5"] dans la liste.
J'ai besoin de construire une structure arborescente à partir de cette liste, qui peut être itéré jusqu'à obtenir un joli imprimé de l'arbre.
comme ce

x1
|
|-x2
|  |
|  |-x3
|  |
|  |-x4
|
|-x5

Toutes les idées/suggestions?
Je crois que le problème peut être attaqué en premier par le traitement de la liste de chaînes de caractères EDIT: La réponse correcte choisi une élégante mise en œuvre, d'autres suggestions ont été trop bonne.

source d'informationauteur sushant

  1. 32

    Suivre une implémentation naïve de la mise en œuvre d'un visitables arbre:

    class Tree<T> implements Visitable<T> {

    //NB: LinkedHashSet preserves insertion order
    private final Set<Tree> children = new LinkedHashSet<Tree>();
    private final T data;

    Tree(T data) {
        this.data = data;
    }

    void accept(Visitor<T> visitor) {
        visitor.visitData(this, data);

        for (Tree child : children) {
            Visitor<T> childVisitor = visitor.visitTree(child);
            child.accept(childVisitor);
        }
    }

    Tree child(T data) {
        for (Tree child: children ) {
            if (child.data.equals(data)) {
                return child;
            }
        }

        return child(new Tree(data));
    }

    Tree child(Tree<T> child) {
        children.add(child);
        return child;
    }
}

    interfaces pour les Visiteurs Modèle:

    interface Visitor<T> {

    Visitor<T> visitTree(Tree<T> tree);

    void visitData(Tree<T> parent, T data);
}

interface Visitable<T> {

    void accept(Visitor<T> visitor);
}

    exemple de mise en œuvre pour les Visiteurs Modèle:

    class PrintIndentedVisitor implements Visitor<String> {

    private final int indent;

    PrintIndentedVisitor(int indent) {
        this.indent = indent;
    }

    Visitor<String> visitTree(Tree<String> tree) {
        return new IndentVisitor(indent + 2);
    }

    void visitData(Tree<String> parent, String data) {
        for (int i = 0; i < indent; i++) { //TODO: naive implementation
            System.out.print(" ");
        }

        System.out.println(data);
    }
}

    et enfin (!!!) un simple cas de test:

        Tree<String> forest = new Tree<String>("forest");
    Tree<String> current = forest;

    for (String tree : Arrays.asList("x1/x2/x3", "x1/x2/x4", "x1/x5")) {
        Tree<String> root = current;

        for (String data : tree.split("/")) {
            current = current.child(data);
        }

        current = root;
    }

    forest.accept(new PrintIndentedVisitor(0));

    de sortie:

    forêt 
x1 
x2 
x3 
x4 
x5
  2. 10

    Juste diviser chaque chemin par ses séparateur, puis les ajouter à une structure en arbre, un par un.

    c'est à dire si 'x1' n'existe pas de créer ce nœud, s'il n'existe pas d'y aller et vérifier si il y a un enfant 'x2' et ainsi de suite...

  3. 4

    Je ferais l'arbre, une corde à la fois.

    Faire un arbre vide (qui a un nœud racine - je suppose, pourrait être une piste comme "x7/x8/x9").

    Prenez la première chaîne, ajoutez x1 vers le nœud racine, alors x2 x1, puis x3 à x2.

    Prendre la deuxième chaîne, voir que x1 et x2 sont déjà là, ajouter x4 à x2.

    Le faire pour chaque chemin que vous avez.

  4. 2

    Créer un Nœud d'Objet qui contient un parent (Nœud) et d'une Liste d'enfants (Nœud).

    Première division de la chaîne à l'aide de ",". Pour chaque découpé chaîne de diviser la chaîne à l'aide de "/".
    La recherche de la première identificateur de noeud (e.g x1) à la racine de la liste.
    Si vous pouvez le trouver, utilisez le nœud de trouver la prochaine identificateur de nœud (par exemple, x2).

    Si vous ne pouvez pas trouver un nœud, ajouter le nœud pour le dernier nœud de vous a pu trouver dans les listes existantes.

    Après avoir créé la structure de la liste, vous pouvez imprimer la liste à l'écran. Je voudrais faire récursive.

    PAS TESTÉ, juste une animation

    public void print(List nodes, int deep) {
    if (nodes == null || nodes.isEmpty()) {
        return;
    }

    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < deep; i++) {
        buffer.append("---");
    }

    for (Iterator iterator = nodes.iterator(); iterator.hasNext();) {
        Node node = (Node)iterator.next();

        System.out.println(buffer.toString() + " " + node.getIdentifier());

        print(node.getChildren(), deep + 1);
    }
}
  5. 0

    Faire votre arbre pour chaque chaîne de caractères en tableau.
    Juste diviser chemin '/' , vérifiez si le nœud existe dans votre arbre ou pas, si elle existe, puis passer à la suite... sinon créer un nouveau nœud et ajoutez ce nœud dans les enfants du nœud parent.

    Itération en utilisant la récursivité.

    Suivant est le modèle de l'arbre du nœud.

    Class Node{
    string name;
    List<Node> childrens;

    Node(string name){
        this.name = name;
        this.childrens = new List<Node>();
    }
}