Discussion :

[jv-boy]

Bonjour,

J'aimerais remplir un arbre java de la facon suivante :

Un texte de type :

a b c d|e f g|h

donnerais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
                 a
                 |
                 b
                 |
                 c
               /   \
              d     e
              |     |
              f     f
             / \   / \
           g  h  g   h

Pour le moment j'ai fait l'algo suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
    ArrayList<String> patterns;
    ArrayList<Node> nodes;
    Node root;
    int deep = 0;
    private String pattern[];
 
    public void build() {
	nodes = new ArrayList<Node>();
	for (int i=0; i<patterns.size(); i++) {
	    pattern = patterns.get(i).split(" ");
	    root = createNode();
	    nodes.add(root);
	}
    }
 
    public Node createNode() {
	Node tmp = new Node();
 
	if (deep < pattern.length) {
	    deep++;
	    for (int i=0; i<pattern.length; i++) {
				Node node = new Node();
				node.setValue(pattern[deep-1]);
				node.addChild(createNode());
				tmp = node;
			}
			deep--;
		}
		return tmp;
    }
    }

J'arrive donc a cree un arbre normal sans probleme avec mon algo recursif. Mais J'arrive pas a gerer le pipe. Je sais pas si je vais dans la bonne voie.

Une petite idee ?

[kolodz]

Donc ton algo doit ressemblé à cela :

1. Découper ton String en bloque correspondant aux niveaux de l'arbre.

"a b c|d" => { "a", "b", "c|d"}

2. Découper un niveau en ses nodes constituant

"a" => {"a"}
"c|d"=> {"c","d"}

3. Crée les nodes du niveaux courant dans chaque node du niveau précédent.

Je te propose d'avoir 3 méthodes de base :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public String[] splitTreeToLevels(String tree);
public String[] splitLevelToNodes(Strong level);
public List<Node> creetNodes(String[] nodes, List<Node> parents);
// retourne la liste des Nodes crée => on vise la récusivité

L'algo général aurai donc la tête suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
	public List<Node> buildTree(String pattern) {
		List<Node> previousLevel = new ArrayList<Node>();
		Node root = new Node("root");
		previousLevel.add(root);
		String levels = splitTreeToLevels(pattern);
		for (String level : levels) {
			String nodes = splitLevelToNodes(level);
			previousLevel = creetNodes(nodes, previousLevel);
		}
		return root;
	}

Cordialement,
Patrick Kolodziejczyk

[jv-boy]

ok super merci, je test tout de suite