LinkBased Binary Tree

[Andrew Marcus]

I have already implemented a java program with all traversals method
but I now slightly want to implement functions remove and add node in
it.Can anyone please provide me the least help?My Program is as
follows:-

import java.io.*;
import java.util.*;

interface Node {
Object element();
void setElement(Object O);
BinNode getLeft();
void setLeft(BinNode n);
BinNode getRight();
void setRight(BinNode n);
BinNode getParent();
void setParent(BinNode n);

}

interface BinTree {
int size();
boolean isEmpty();
boolean isInternal(Node n);
boolean isLeaf(Node n);
boolean isRoot(Node n);
Node root();
Node leftChild(Node n);
Node rightChild(Node n);
Node sibling(Node n);
Node parent(Node n);
Object replaceElement(Node n,Object O);
void swap(Node n,Node m);
}

class BinNode implements Node {
BinNode left,right,parent;
Object element;
public BinNode() { }

public BinNode(Object O,BinNode p,BinNode n,BinNode m) {
setElement(O);
setParent(p);
setLeft(n);
setRight(m);

}

public Object element() { return element;}

public void setElement(Object O) { element=O; }

public BinNode getLeft() { return left; }

public void setLeft(BinNode n) { left=n; }

public BinNode getRight() { return right; }

public void setRight(BinNode m) { right=m; }

public BinNode getParent() { return parent; }

public void setParent(BinNode p) { parent=p; }

}

public class LinkBinTree implements BinTree {

Node root;
int size;

public LinkBinTree() {
root = new BinNode(null,null,null,null);
size = 1;
}

public int size() { return size; }

public boolean isEmpty() { return (size==0); }

public boolean isInternal(Node n) {
return(((BinNode)n).getLeft()!=null && ((BinNode)n).getRight()!
=null);
}

public boolean isLeaf(Node n) {
return(((BinNode)n).getLeft()==null &&
((BinNode)n).getRight()==null);
}

public boolean isRoot(Node n) { return (n==root()); }

public Node root() { return root; }

void printInOrder(Node t){
if ( t != null)
{ printInOrder(t.getLeft());
System.out.println(" " +t.element() );
printInOrder(t.getRight());
}
}
void printPreOrder(Node t){
if ( t != null)
{
System.out.println(" " +t.element() );
printPreOrder(t.getLeft());
printPreOrder(t.getRight());
}
}

void printPostOrder(Node t){
if ( t != null)
{ printPostOrder(t.getLeft());
printPostOrder(t.getRight());
System.out.println(" " +t.element() );
}
}

void breadthFirst(Node t) {
ArrayQueue<Node> Q = new ArrayQueue<Node>();
Q.enqueue(t);
while(!Q.isEmpty()) {
t = Q.dequeue();
System.out.print(" " + t.element() );
Node l=t.getLeft();
Node r=t.getRight();
if(l!=null)Q.enqueue(l);
if(r!=null)Q.enqueue(r);
}
}

public Node leftChild(Node n) { return
((BinNode)n).getLeft(); }

public Node rightChild(Node n) { return
((BinNode)n).getRight(); }

public Node sibling(Node n) {
Node q = parent(n);
Node l = leftChild(q);
if(n == l) return rightChild(q);
else
return l; }

public Node parent(Node n) { return((BinNode)n).getParent(); }

public Object replaceElement(Node n,Object O) {
Object temp = ((BinNode)n).element();
((BinNode)n).setElement(O);
return temp; }

public void swap(Node n,Node m) {
Object temp = m.element();
((BinNode)m).setElement(n.element());
((BinNode)n).setElement(temp);
}
public static void main(String[] args) {
LinkBinTree tree = new LinkBinTree();
System.out.println("The root of the tree was "
+tree.root.element());
BinNode A=new BinNode(new Integer(13),null,null,null);
BinNode B=new BinNode(new Integer(27),A,null,null);
BinNode C=new BinNode(new Integer(33),B,null,null);
BinNode D=new BinNode(new Integer(49),A,null,null);
BinNode E=new BinNode(new Integer(57),B,null,null);
BinNode F=new BinNode(new Integer(62),D,null,null);
BinNode G=new BinNode(new Integer(99),D,null,null);

A.setLeft(B);A.setRight(D);B.setLeft(C);B.setRight(E);D.setLeft(F);D.setRight(G);
System.out.println("The root of the tree is now "
+A.element());
System.out.println("The inorder tree is");
tree.printInOrder((Node)A);
System.out.println("The preorder tree is");
tree.printPreOrder((Node)A);
System.out.println("The postorder tree is");
tree.printPostOrder((Node)A);
System.out.println("The breadthFirst tree is");
tree.breadthFirst((Node)A);
System.out.println();
System.out.println();

}
}