LinkBased Binary Tree

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();

              }
}