Generic (n-ary) Tree in Java

After writing a class for a Generic Tree Node, we need to write a Generic Tree class, which will use Generic Tree Nodes to build a Generic Tree:

GenericTreeTraversalOrderEnum.java
[sourcecode lang="java"]
public enum GenericTreeTraversalOrderEnum {
PRE_ORDER,
POST_ORDER
}
[/sourcecode]

GenericTree.java
[sourcecode lang="java"]
import java.util.*;

public class GenericTree {

private GenericTreeNode root;

public GenericTree() {
super();
}

public GenericTreeNode getRoot() {
return this.root;
}

public void setRoot(GenericTreeNode root) {
this.root = root;
}

public int getNumberOfNodes() {
int numberOfNodes = 0;

if(root != null) {
numberOfNodes = auxiliaryGetNumberOfNodes(root) + 1; //1 for the root!
}

return numberOfNodes;
}

private int auxiliaryGetNumberOfNodes(GenericTreeNode node) {
int numberOfNodes = node.getNumberOfChildren();

for(GenericTreeNode child : node.getChildren()) {
numberOfNodes += auxiliaryGetNumberOfNodes(child);
}

return numberOfNodes;
}

public boolean exists(GenericTreeNode nodeToFind) {
return (find(nodeToFind) != null);
}

public GenericTreeNode find(GenericTreeNode nodeToFind) {
GenericTreeNode returnNode = null;

if(root != null) {
returnNode = auxiliaryFind(root, nodeToFind);
}

return returnNode;
}

private GenericTreeNode auxiliaryFind(GenericTreeNode currentNode, GenericTreeNode nodeToFind) {
GenericTreeNode returnNode = null;
int i = 0;

if (currentNode.equals(nodeToFind)) {
returnNode = currentNode;
}

else if(currentNode.hasChildren()) {
i = 0;
while(returnNode == null && i < currentNode.getNumberOfChildren()) { returnNode = auxiliaryFind(currentNode.getChildAt(i), nodeToFind); i++; } } return returnNode; } public boolean isEmpty() { return (root == null); } public List> build(GenericTreeTraversalOrderEnum traversalOrder) {
List> returnList = null;

if(root != null) {
returnList = build(root, traversalOrder);
}

return returnList;
}

public List> build(GenericTreeNode node, GenericTreeTraversalOrderEnum traversalOrder) {
List> traversalResult = new ArrayList>();

if(traversalOrder == GenericTreeTraversalOrderEnum.PRE_ORDER) {
buildPreOrder(node, traversalResult);
}

else if(traversalOrder == GenericTreeTraversalOrderEnum.POST_ORDER) {
buildPostOrder(node, traversalResult);
}

return traversalResult;
}

private void buildPreOrder(GenericTreeNode node, List> traversalResult) {
traversalResult.add(node);

for(GenericTreeNode child : node.getChildren()) {
buildPreOrder(child, traversalResult);
}
}

private void buildPostOrder(GenericTreeNode node, List> traversalResult) {
for(GenericTreeNode child : node.getChildren()) {
buildPostOrder(child, traversalResult);
}

traversalResult.add(node);
}

public Map, Integer> buildWithDepth(GenericTreeTraversalOrderEnum traversalOrder) {
Map, Integer> returnMap = null;

if(root != null) {
returnMap = buildWithDepth(root, traversalOrder);
}

return returnMap;
}

public Map, Integer> buildWithDepth(GenericTreeNode node, GenericTreeTraversalOrderEnum traversalOrder) {
Map, Integer> traversalResult = new LinkedHashMap, Integer>();

if(traversalOrder == GenericTreeTraversalOrderEnum.PRE_ORDER) {
buildPreOrderWithDepth(node, traversalResult, 0);
}

else if(traversalOrder == GenericTreeTraversalOrderEnum.POST_ORDER) {
buildPostOrderWithDepth(node, traversalResult, 0);
}

return traversalResult;
}

private void buildPreOrderWithDepth(GenericTreeNode node, Map, Integer> traversalResult, int depth) {
traversalResult.put(node, depth);

for(GenericTreeNode child : node.getChildren()) {
buildPreOrderWithDepth(child, traversalResult, depth + 1);
}
}

private void buildPostOrderWithDepth(GenericTreeNode node, Map, Integer> traversalResult, int depth) {
for(GenericTreeNode child : node.getChildren()) {
buildPostOrderWithDepth(child, traversalResult, depth + 1);
}

traversalResult.put(node, depth);
}

public String toString() {
/*
We're going to assume a pre-order traversal by default
*/

String stringRepresentation = "";

if(root != null) {
stringRepresentation = build(GenericTreeTraversalOrderEnum.PRE_ORDER).toString();

}

return stringRepresentation;
}

public String toStringWithDepth() {
/*
We're going to assume a pre-order traversal by default
*/

String stringRepresentation = "";

if(root != null) {
stringRepresentation = buildWithDepth(GenericTreeTraversalOrderEnum.PRE_ORDER).toString();
}

return stringRepresentation;
}
}
[/sourcecode]