Java Link strategy for array implementation of trees? - arrays

Question

My Question:
I have a Java program that searches for the Lowest Common Ancestor in a Binary Tree. That part should work, but my question is regarding my main method so I haven't properly tested it. I need to create a binary tree from the chars stored in my array.
What I've found
To put it simply, not much. I've found a few pages that touch on the subject, but their implementations seem so vastly different from the rest of my code. If someone can even provide links to a guide, preferably with code examples, that could possibly answer my question.
My Code
public class TreeMain
{
static TreeNode root;
public static void main(String args[])
{
String[] myStringsChars = new String[26];
for(int i = 0; i < 26; i++)
{
myStringChars[i] = new String(Character.toChars(i+65));
System.out.println(myStringChars[i]);
}
// array to binary tree
TreeNode commonAncestor = findLowestCommonAncestor(firstNode, secondNode);
if(commonAncestor != null) {
System.out.println(commonAncestor.getContents()); }
}
public static TreeNode findLowestCommonAncestor(TreeNode node1, TreeNode node2)
{
return findLCA(root, node1, node2);
}
public static TreeNode findLCA(TreeNode node, TreeNode node1, TreeNode node2)
{
if (node == null) {
return null; }
if (node.getContents() == node1 || node.getContents() == node2) {
return node; }
TreeNode leftLCA = findLCA(node.getLeftChild(), node1, node2);
TreeNode rightLCA = findLCA(node.getRightChild(), node1, node2);
if (leftLCA!=null && rightLCA!=null)
return node;
// Otherwise check if left subtree or right subtree is LCA
return (leftLCA != null) ? leftLCA : rightLCA;
}
}
public class TreeNode<T extends Comparable>{
private T contents;
private TreeNode<T> parent;
private TreeNode<T> leftChild;
private TreeNode<T> rightChild;
private int level;
public TreeNode(T data, TreeNode parent)
{
contents = data;
this.parent = parent;
}
public void setLeftChild(TreeNode node)
{
this.leftChild = node;
}
public void setRightChild(TreeNode node)
{
this.rightChild = node;
}
public boolean isContentEquals(T data)
{
return 0 == getContents().compareTo(data);
}
public T getContents() {
return contents;
}
public void setContents(T contents) {
this.contents = contents;
}
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
}
public TreeNode getLeftChild() {
return leftChild;
}
public TreeNode getRightChild() {
return rightChild;
}
public TreeNode findNodeOnTree(T contentToSearch)
{
List<TreeNode> nodes = new LinkedList();
nodes.clear();
nodes.add(this);
while(!nodes.isEmpty())
{
TreeNode current = nodes.remove(0);
if(current.isContentEquals(contentToSearch))
{
return current;
}
if(current.leftChild != null)
{
nodes.add(current.leftChild);
}
if(current.rightChild != null)
{
nodes.add(current.rightChild);
}
}
return null;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
}

Answer 1

I haven't tried your algorithm yet, but the part you are looking for should be pretty straightforward. One quick way to achieve it would be to draw the picture of the binary tree you have in mind and just write a couple of methods to translate that picture to code. Here's what I'd start with:
public TreeNode<T> addLeft(T key) {
TreeNode<T> tmp = new Node<>(key);
this.left = tmp;
tmp.parent = this; // if you are using parent pointers
return tmp; // for chaining purpose, so returned node can be subject to addition
}
public TreeNode<T> addRight(T key) {
TreeNode<T> tmp = new TreeNode<>(key);
this.right = tmp;
tmp.parent = this;
return tmp;
}
To construct the tree, you can create a root node and then call the addLeft() and addRight() methods as you see in the picture of your binary tree:
TreeNode<Character> root = ...; // say root's key is 'A'
TreeNode<Character> left1 = root.addLeft('B');
TreeNode<Character> right1 = root.addRight('C');
//TreeNode<Character> left2 = left1.addLeft();
// and so on for your character array.
A more involved way is to think of the inorder traversal and preorder traversal of the tree that you have in mind, represent the two traversals as two separate arrays and then write another procedure to accept these two arrays that constructs a binary tree out of this. This is left as an exercise.