Si vous faites du codage sur tableau blanc, une interview ou même que vous prévoyez simplement d'utiliser un arbre, la verbosité de tout cela est un peu trop.
Il faut en outre dire que la raison pour laquelle un arbre n'est pas là comme, disons, un Pair
(à propos duquel la même chose pourrait être dite), c'est parce que vous devriez encapsuler vos données dans la classe qui l'utilise, et l'implémentation la plus simple ressemble à:
/***
/* Within the class that's using a binary tree for any reason. You could
/* generalize with generics IFF the parent class needs different value types.
*/
private class Node {
public String value;
public Node[] nodes; // Or an Iterable<Node> nodes;
}
C'est vraiment tout pour un arbre de largeur arbitraire.
Si vous vouliez un arbre binaire, il est souvent plus facile à utiliser avec des champs nommés:
private class Node { // Using package visibility is an option
String value;
Node left;
Node right;
}
Ou si vous vouliez un trie:
private class Node {
String value;
Map<char, Node> nodes;
}
Maintenant tu as dit que tu voulais
pour pouvoir obtenir tous les enfants (une sorte de liste ou de tableau de chaînes) étant donné une chaîne d'entrée représentant un nœud donné
Cela ressemble à vos devoirs.
Mais comme je suis raisonnablement sûr que tout délai est maintenant passé…
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
public class kidsOfMatchTheseDays {
static private class Node {
String value;
Node[] nodes;
}
// Pre-order; you didn't specify.
static public List<String> list(Node node, String find) {
return list(node, find, new ArrayList<String>(), false);
}
static private ArrayList<String> list(
Node node,
String find,
ArrayList<String> list,
boolean add) {
if (node == null) {
return list;
}
if (node.value.equals(find)) {
add = true;
}
if (add) {
list.add(node.value);
}
if (node.nodes != null) {
for (Node child: node.nodes) {
list(child, find, list, add);
}
}
return list;
}
public static final void main(String... args) {
// Usually never have to do setup like this, so excuse the style
// And it could be cleaner by adding a constructor like:
// Node(String val, Node... children) {
// value = val;
// nodes = children;
// }
Node tree = new Node();
tree.value = "root";
Node[] n = {new Node(), new Node()};
tree.nodes = n;
tree.nodes[0].value = "leftish";
tree.nodes[1].value = "rightish-leafy";
Node[] nn = {new Node()};
tree.nodes[0].nodes = nn;
tree.nodes[0].nodes[0].value = "off-leftish-leaf";
// Enough setup
System.out.println(Arrays.toString(list(tree, args[0]).toArray()));
}
}
Cela vous permet d'utiliser comme:
$ java kidsOfMatchTheseDays leftish
[leftish, off-leftish-leaf]
$ java kidsOfMatchTheseDays root
[root, leftish, off-leftish-leaf, rightish-leafy]
$ java kidsOfMatchTheseDays rightish-leafy
[rightish-leafy]
$ java kidsOfMatchTheseDays a
[]