Since this is tagged as homework, you are probably expected to write it yourself.
Usually when it comes to traversing a tree, you don't have too many chances of optimizing, because starting at a node, you only have the options to visit the parent node or the child nodes. (As opposed to a graph, where you might apply Dijkstra's algorithm)
Just try it, i would recommend recursion.
A Node usually looks like this:
public class Node {
public String value; //contains "C" or "D" etc
public List<Node> children = new ArrayList<Node>();
public Node parent;
public Node(Node parent){
this.parent = parent;
}
public Node(Node parent, String value){
this.parent = value;
this.value = value;
}
public boolean equals(Object n){//Nodes are equal if they have the same value
return value.equals(((Node)n).value);
}
}
If the question is to find the minimum number of steps from A to B (which is the distance), i would implement a distanceTo Method that traverses the tree and looks for the target Node until it is found. If you never worked with trees before, that might be a bit tricky.
Ok, since you never worked with Trees before:
A tree is a data structure that contains a certain amount of Nodes. The connections between the Nodes are represented by references between the Nodes.
Each Node has a reference to it's parent Node (the one above) and a list of child nodes (the nodes below). A Node can only have one parent, but any number of children. A node without any children is called a leaf. The root node is usually identifyable because it's parent attribute is null (because the root, which is the topmost node, has no parent). All other nodes in the tree have parent!=null.
The starting point for a Tree is the root Node. The following code creates the topmost 3 Nodes from your picture (where the type Node is the java class above):
Node nodeRoot = new Node(null, "root"); //create a node with parent=null
Node nodeA = new Node(nodeRoot, "A");
Node nodeB = new Node(nodeRoot, "B");
nodeRoot.children.add(nodeA); //you could also place this functionality
nodeRoot.children.add(nodeB); // in the constructor of Node
You now have 3 a tree (starting at nodeRoot) with 3 nodes: "root", "A" and "B".
You could now show all nodes that are direct children of the root node:
for(Node child:nodeRoot.children){
System.out.println(child.value);
}
/* prints:
A
B
*/
Or print the value of a parent's node:
System.out.println(nodeA.parent.value);
/*prints:
root
*/
Try to complete the code to create a tree that represents the one in your picture!
To continue (-> tree traversal), I would strongly advise you to read something about it first. Focus on Depth-First-Traversal and Breadth-First-Traversal and make sure you understand the difference.
Regarding "Non-Binary Trees":
This does work very well for non-binary trees. The definition of Binary Trees states:
a binary tree is a tree data structure in which each node has at most two children.
Since I used a List of Nodes in the java class above, you can use any number of children per node. In fact, you would have to invest extra work to make the class compliant to a binary tree - which means making sure that each node can only have 0, 1 or 2 children.
For non-binary trees you can a) use the class above and b) apply the same algorithms (BFS/DFS).
