import java.util.Queue; import java.util.LinkedList; import java.util.NoSuchElementException; public class BinaryTree<T extends Comparable<T>> { BTNode root; public BinaryTree() { root = null; } public BinaryTree(BTNode root) { root = null; } public void purge(){ root = null; } public boolean isEmpty(){ return root == null; } public void insert(T key){ if (root == null) { root = new BTNode(key); return; } BTNode temp; Queue<BTNode> q = new LinkedList<BTNode>(); q.add(root); // Do level order traversal until we find the first empty left or right child. while (!q.isEmpty()) { temp = q.poll(); if (temp.left == null) { temp.left = new BTNode(key); break; } else q.add(temp.left); if (temp.right == null) { temp.right = new BTNode(key); break; } else q.add(temp.right); } } // delete by copying last node public void deleteByCopying(T data){ if(root == null) throw new UnsupportedOperationException("Tree is empty!"); else if(root.left == null && root.right == null){ if(root.data.equals(data)) root = null; else throw new NoSuchElementException(data + " not in the tree."); return; } Queue<BTNode> queue = new LinkedList<BTNode>(); queue.add(root); BTNode keyNode = null; BTNode currentNode = null; BTNode parentNode = root; boolean found = false; while(! queue.isEmpty()){ currentNode = queue.poll(); if(currentNode.data.equals(data)){ if(! found){ keyNode = currentNode; found = true; } } if(currentNode.left != null){ queue.add(currentNode.left); parentNode = currentNode; } if(currentNode.right != null){ queue.add(currentNode.right); parentNode = currentNode; } } if(! found) throw new NoSuchElementException(data + " not in tree."); while(! queue.isEmpty()){ currentNode = queue.poll(); System.out.print(currentNode.data + " "); if(currentNode.left != null){ queue.add(currentNode.left); parentNode = currentNode; } if(currentNode.right != null){ queue.add(currentNode.right); parentNode = currentNode; } } keyNode.data = currentNode.data; if(parentNode.left == currentNode) parentNode.left = null; else if(parentNode.right == currentNode) parentNode.right = null; } public void levelOrderTraversal(){ // BreadthFirstTraversal levelOrderTraversal(root); } // BreadthFirst Traversal protected void levelOrderTraversal(BTNode root){ if(root == null) return; Queue<BTNode> queue = new LinkedList<BTNode>(); BTNode node = root; queue.add(node); while(! queue.isEmpty()){ node = queue.poll(); visit(node); if(node.left != null) queue.add(node.left); if(node.right != null) queue.add(node.right); } } public void levelOrderTraversalByLevels(){ levelOrderTraversalByLevels(root); } protected void levelOrderTraversalByLevels(BTNode<T> root){ Queue q = new LinkedList(); int levelNodes = 0; if(root==null) return; q.add(root); while(!q.isEmpty()){ levelNodes = q.size(); while(levelNodes>0){ BTNode n = (BTNode)q.remove(); System.out.print(" " + n.data); if(n.left!=null) q.add(n.left); if(n.right!=null) q.add(n.right); levelNodes--; } System.out.println(""); } } protected void visit(BTNode<T.

1. import java.util.Queue;
import java.util.LinkedList;
import java.util.NoSuchElementException;
public class BinaryTree<T extends Comparable<T>> {
BTNode root;
public BinaryTree() {
root = null;
}
public BinaryTree(BTNode root) {
root = null;
}
public void purge(){
root = null;
}
public boolean isEmpty(){
return root == null;
}
public void insert(T key){
if (root == null) {
root = new BTNode(key);
return;
}
BTNode temp;
Queue<BTNode> q = new LinkedList<BTNode>();
q.add(root);
// Do level order traversal until we find the first empty left or right child.
while (!q.isEmpty()) {
temp = q.poll();
if (temp.left == null) {
temp.left = new BTNode(key);
break;
}
else
q.add(temp.left);
if (temp.right == null) {
temp.right = new BTNode(key);
break;
}
else
q.add(temp.right);
}
}

2. // delete by copying last node
public void deleteByCopying(T data){
if(root == null)
throw new UnsupportedOperationException("Tree is empty!");
else if(root.left == null && root.right == null){
if(root.data.equals(data))
root = null;
else
throw new NoSuchElementException(data + " not in the tree.");
return;
}
Queue<BTNode> queue = new LinkedList<BTNode>();
queue.add(root);
BTNode keyNode = null;
BTNode currentNode = null;
BTNode parentNode = root;
boolean found = false;
while(! queue.isEmpty()){
currentNode = queue.poll();
if(currentNode.data.equals(data)){
if(! found){
keyNode = currentNode;
found = true;
}
}
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
if(! found)
throw new NoSuchElementException(data + " not in tree.");
while(! queue.isEmpty()){
currentNode = queue.poll();
System.out.print(currentNode.data + " ");
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;

3. }
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
keyNode.data = currentNode.data;
if(parentNode.left == currentNode)
parentNode.left = null;
else if(parentNode.right == currentNode)
parentNode.right = null;
}
public void levelOrderTraversal(){ // BreadthFirstTraversal
levelOrderTraversal(root);
}
// BreadthFirst Traversal
protected void levelOrderTraversal(BTNode root){
if(root == null)
return;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
visit(node);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
}
public void levelOrderTraversalByLevels(){
levelOrderTraversalByLevels(root);
}
protected void levelOrderTraversalByLevels(BTNode<T> root){
Queue q = new LinkedList();
int levelNodes = 0;
if(root==null)
return;
q.add(root);
while(!q.isEmpty()){
levelNodes = q.size();

4. while(levelNodes>0){
BTNode n = (BTNode)q.remove();
System.out.print(" " + n.data);
if(n.left!=null)
q.add(n.left);
if(n.right!=null)
q.add(n.right);
levelNodes--;
}
System.out.println("");
}
}
protected void visit(BTNode<T> p) {
System.out.print(p.data + " ");
}
public void inorderTraversal(){
inorderTraversal(root);
}
protected void inorderTraversal(BTNode node) {
if (node == null)
return;
inorderTraversal(node.left);
visit(node);
inorderTraversal(node.right);
}
public void postorderTraversal(){
postorderTraversal(root);
}
protected void postorderTraversal(BTNode node){
if (node == null)
return;
postorderTraversal(node.left);
postorderTraversal(node.right);
visit(node);
}
public void preorderTraversal(){
preorderTraversal(root);
}
protected void preorderTraversal(BTNode node){
if (node == null)
return;
visit(node);

5. preorderTraversal(node.left);
preorderTraversal(node.right);
}
public boolean search(T key){
if(root == null)
return false;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
if(key.equals(node.data))
return true;
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
return false;
}
public void printTree(){
printTree(root, "", true);
}
// Print the binary tree
protected void printTree(BTNode currPtr, String indent, boolean last) {
if(indent.equals(""))
System.out.print("t");
if (currPtr != null) {
System.out.print(indent);
if (last) {
System.out.print("R----");
indent += " ";
} else {
System.out.print("L----");
indent += "| ";
}
System.out.println(currPtr.data);
printTree(currPtr.left, indent, false);
printTree(currPtr.right, indent, true);
}
}
//******************************************************************************

6. }
Given the information and the code above, using Java solve this task:
(Please make sure that the method is boolean not int)
BinaryTree insertion and deletion There are no fixed rules for inserting and deleting from a Binary-
tree. In our Binary-tree implementation, we use the insertion and deletion algorithms given below: -
Given a binary tree and a key, insert the key into the binary tree at the first position available in
level order traversal. Note: We can create a Binary tree without using the insert method. We do
this by creating the root node and then linking it with other nodes: BinaryTree> tree = new
BinaryTree Integer >(); BTNode node1 = new BTNode (7); BTNode node2 = new BTNode (4);
BTNode node 3= new BTNode (28); tree.root = node 1 node1.left = node 2; node2.right = node3; -
Given a binary tree, delete a node from it by making sure that tree shrinks from the bottom (i.e. the
deleted node is replaced by the last leaf node).Lab Tasks 1. Write a recursive instance method
public boolean subtreesHaveEqualNumberofNodes() of the BinaryTree <T> class that returns true
if the invoking Binary T ree <T> object has an equal number of nodes in its left and right subtrees.
Your method must throw java.lang.UnsupportedOperationException if the invoking tree is empty.