import java.util.ArrayList;
import java.util.List;

public class BinaryTree<T> {

BinaryNode<T> root = null;

private T nullSymbol = null;

/**
* Default constructor
*/
public BinaryTree() {

}

/**
* This constructor is useful for test purposes, not meant for use in
* general.
*
* Constructs a binary tree from a given valid breadth-first traversal
* sequence.
*
* @param seq is an array containing breadth-first traversal sequence of the
* nodes of a tree.
*/
public BinaryTree(T[] seq) {
   initFromBfsSequence(seq);
}

/**
* This constructor is useful for test purposes, not meant for use in
* general.
*
* Constructs a binary tree from a given valid breadth-first traversal
* sequence. A given special symbol (nullSymbol) in the sequence is
* interpreted as absence of node. During construction of the tree, when
* such a special symbol is encountered, that is considered to be an absent
* node, and thus no corresponding node is added to the tree.
*
* @param seq is an array containing breadth-first traversal sequence of the
* nodes of a tree.
* @param nullSymbol is a special symbol in the given sequence that denotes
* absence of a node.
*/
public BinaryTree(T[] seq, T nullSymbol) {
   this.nullSymbol = nullSymbol;
   initFromBfsSequence(seq);
}

private void initFromBfsSequence(T[] seq) {
   try {
         if (seq.length == 0) {
            throw new IllegalArgumentException("Cannot build tree from empty sequence");
         }
   } catch (IllegalArgumentException e) {
         System.out.println(e.getMessage());
         return;
   }

   try {
         if (seq[0].equals(nullSymbol)) {
            throw new IllegalArgumentException("Symbol for root cannot be nullSymbol");
         }
   } catch (IllegalArgumentException e) {
         System.out.println(e.getMessage());
         return;
   }
   /*if (seq.length == 0) {
         throw new IllegalArgumentException("Cannot build tree from empty sequence");
   }

   if (seq[0].equals(nullSymbol)) {
         throw new IllegalArgumentException("Symbol for root cannot be nullSymbol");
   }
*/
   List<BinaryNode<T>> nodes = new ArrayList<BinaryNode<T>>(seq.length);
   this.root = new BinaryNode<T>(seq[0]);
   nodes.add(root);

   for (int i = 0; i < seq.length; i++) {
         if (nodes.get(i) == null) {
            handelNullParentNode(nodes, i, seq.length);
         } else {
            handleNonNullParentNode(nodes, i, seq);
         }
   }
}

// This method will handle the null nodes in the iteration of nodes.get(i) in initFromBfsSequence method.
private void handelNullParentNode(List<BinaryNode<T>> nodes,
         int nullNodeIndex, int seqLength) {
   int leftIndex = (nullNodeIndex * 2) + 1; // finding the left child index from formula

   if (leftIndex < seqLength) {
         nodes.add(null);

         int rightIndex = (nullNodeIndex * 2) + 2; // finding the right child index from formula
         if (rightIndex < seqLength) {
            nodes.add(null);
         }
   }
}

// This method will handle the non-null nodes in the iteration of nodes.get(i) in initFromBfsSequence method.
private void handleNonNullParentNode(List<BinaryNode<T>> nodes,
         int parentIndex, T[] seq) {
   int leftIndex = (parentIndex * 2) + 1;
   if (leftIndex < seq.length) { //need to check if the index falls outdise of the list index
         BinaryNode<T> leftNode = null;
         if (!seq[leftIndex].equals(nullSymbol)) {
            leftNode = new BinaryNode<T>(seq[leftIndex]);
         }
         nodes.get(parentIndex).leftNode = leftNode;
         nodes.add(leftNode);

         int rightIndex = (parentIndex * 2) + 2;
         if (rightIndex < seq.length) {
            BinaryNode<T> rightNode = null;
            if (!seq[rightIndex].equals(nullSymbol)) {
               rightNode = new BinaryNode<T>(seq[rightIndex]);
            }
            nodes.get(parentIndex).rightNode = rightNode;
            nodes.add(rightNode);
         }
   }
}

Firefighting Communication System Brainstorming phase People in...