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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
| public class TraceNode {
/* Résultat voulu :
[0]
\ \ \ \
[1, 2, 3, 4]
\ \ \ \ \ \
[11, 12, 13, 21, 22, 31]
\ \ \ \
[111, 112, 121, 211]
\
[1111]
*/
public static void main(String[] args) {
DefaultMutableTreeNode node = createTree("[0], [1, 2, 3, 4], [11, 12, 13, 21, 22, 31], [111, 112, 121, 211], [1111] "); // création
// vérif construction traceNode(node,"");
printNode(node); // affichage
}
// méthode pour tracer l'arbre construit, juste pour vérifier que la construction est ok
private static void traceNode(DefaultMutableTreeNode node, String indent) {
System.out.println(indent+node.getUserObject());
for(int i=0; i<node.getChildCount(); i++) {
traceNode((DefaultMutableTreeNode) node.getChildAt(i), indent+".");
}
}
// affichage de l'arbre
public static void printNode(DefaultMutableTreeNode node) {
Map<Integer, List<String>> map = new HashMap<>();
// construction des listes par niveau
buildPrintMap(node, map, 0);
int level=0;
while( map.containsKey(level) ) {
List<String> list = map.get(level);
// "branches"
for(int i=0; i<list.size(); i++) {
System.out.print("\\ ");
}
System.out.println();
// list
System.out.println(list);
level++;
}
}
private static void buildPrintMap(DefaultMutableTreeNode node,
Map<Integer, List<String>> map, int level) {
List<String> list = map.get(level);
// on créé une liste pour le niveau courant si n'existe pas encore
if ( list==null ) {
list = new ArrayList<>();
map.put(level, list);
}
// on ajoute le "label" du node courant
list.add(getLabel(node));
// solution alternative list.add(getLabel2(node));
// on traite les enfants, pour le niveau suivant
for(int i=0; i<node.getChildCount(); i++) {
buildPrintMap((DefaultMutableTreeNode) node.getChildAt(i), map, level+1);
}
}
// création du label d'un node
private static String getLabel(DefaultMutableTreeNode node) {
StringBuilder sb=new StringBuilder();
getLabel(node, sb);
return sb.toString();
}
private static void getLabel(DefaultMutableTreeNode node, StringBuilder sb) {
if ( node.getParent()==null ) {
// cas particulier de la racine
if ( sb.length()==0 ) {
// on affiche le 0 que pour la racine
sb.append('0');
}
}
else {
// on cherche sa position dans le parent
int index = node.getParent().getIndex(node);
// comme on remonte, on doit insérer l'index devant (on pourrait le faire après, s'il n'y avait pas le cas du 0)
sb.insert(0, index+1);
// on remonte dans le parent
getLabel((DefaultMutableTreeNode) node.getParent(), sb);
}
}
// Solution alternative
// création du label d'un node
private static String getLabel2(DefaultMutableTreeNode node) {
StringBuilder sb=new StringBuilder();
getLabel2(node, sb);
return sb.toString();
}
private static void getLabel2(DefaultMutableTreeNode node, StringBuilder sb) {
if ( node.getParent()==null ) {
sb.append('0');
}
else {
// on cherche sa position dans le parent
int index = node.getParent().getIndex(node);
// comme on remonte, on doit insérer l'index devant (on pourrait le faire après, s'il n'y avait pas le cas du 0)
// on remonte dans le parent, sauf s'il se trouve à la racine
if ( node.getParent().getParent()!=null ) {
getLabel2((DefaultMutableTreeNode) node.getParent(), sb);
}
sb.append(index+1);
}
}
// fin solution alternative
private static DefaultMutableTreeNode createTree(String defn) {
List<String> list = new ArrayList<>();
DefaultMutableTreeNode root = null;
for (String leveldef : defn.split(" \\[[,].*\\],+") ) {
String[] nodedef = leveldef.replaceAll("[\\[\\] ]*", "").split(",");
for(String s: nodedef) {
if ( "0".equals(s) ) {
// root
root = new DefaultMutableTreeNode("0");
}
else {
list.add(s);
}
}
}
for( String def : list ) {
createTree(root, def);
}
return root;
}
private static void createTree(DefaultMutableTreeNode parent,
String nodeDef) {
for(int level=0; level<nodeDef.length(); level++) {
int index = Integer.parseInt(nodeDef.substring(level, level+1))-1;
DefaultMutableTreeNode node = getChildNode(parent, index);
if ( node==null ) {
node=new DefaultMutableTreeNode(nodeDef);
parent.add(node);
}
parent=node;
}
}
private static DefaultMutableTreeNode getChildNode(DefaultMutableTreeNode parent, int index) {
if ( parent.getChildCount()>index ) {
return (DefaultMutableTreeNode) parent.getChildAt(index);
}
return null;
}
} |
