I want to generate a tree from an array(such as String), but I don't know how to do it.
My input array:
[a, f, d, s]
[a, f, w]
[b, r]
[a, p]
[b, n, l]
I want to make a tree like this:
Root
b
r
n
l
a
f
w
d
s
p
This is my code so far:
public class TreeGenerator {
public TreeGenerator(E root, E[][] array){
List list = Arrays.asList(array);//makes list
Set set = new HashSet(list);//then set
Node tree = new Node(root, set, 0);//makes whole tree
System.out.println(tree.toString());//displays tree
}
public static void main(String[] args) {
String[][] array = new String[][] { { "a", "f", "d", "s" }, { "a", "f", "w" }, { "b", "r" }, { "a", "p" }, { "b", "n", "l" } };
for(String[] s : array){
System.out.println(Arrays.toString(s));
}
new TreeGenerator("Root", array);
}
}
public class Node {
private final E nodeName;
private final Node[] children;
private final int depth;
/**
* Constructs a Node and its children.
*
* @param name Node name
* @param array Set of arrays
* @param depth Index of arrays
*/
public Node(E name, Set array, int depth) {
nodeName = name;
this.depth = depth;
Map map = new HashMap();
for (E[] line : array) { //iterates over arrays
if (line.length > depth) { //checks if an element exists at this depth
E common = line[depth]; //gets an element
Set branch = map.get(common); //gets a branch for the element
if (branch == null) { //if first such an element
branch = new HashSet(); //creates branch
map.put(common, branch); //adds for the element
}
branch.add(line); //adds the line for proper branch
}
}
children = new Node[map.size()];
int i = 0;
depth++;//gets deeper
for (Map.Entry entry : map.entrySet()) {//iterates over map
children[i] = new Node(entry.getKey(), entry.getValue(), depth);//makes child
i++;
}
}
}
You're code is a bit chaotic and you should most definitly not create the entire structure recursively in the constructor of Node
. So i've provided some pseudocode
define generateTree:
input: string[][] struct
output: tree
node root
//each string[] describes on path from the root to a leaf of the tree
for string[] s in struct
node tmp = root
//complete a path
for string n in s
//check whether the next node is already part of the tree
if hasChild(tmp , n)
//continue with the next node in the path
tmp = getChild(tmp , n)
else
//next node doesn't exist -> create it first
node child = new node(n)
add(tmp , child)
tmp = child
return tree(root)
Though this form of representation is rather inefficient and will produce gigantic amounts of data for bigger balanced trees.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.