Binary Tree in Java - Abhijeet Hacking Articles

Here is a example of Binary Tree in Java which my friend CodeZero wrote.
Copy it in your IDE or notepad and save it as "Test1.java"
You will need JDK to run this. Download it form here.
To run this open up the terminal or command prompt and type :
javac Test1.java
java Test1
 /*  
 Author:_ash_  
 InputTree:  
 -------50  
 ------/--\  
 -----10--70  
 ----/-\---\  
 ---5--20--80  
 -----/--\  
 ----15---30  
 ----/  
 ---12  
 */  
 public class Test1 {  
      public static void main(String args[]){  
           BinaryTree b1=new BinaryTree();  
           b1.add(50);  
           b1.add(10);  
           b1.add(5);  
           b1.add(15);  
           b1.add(12);  
           b1.add(20);  
           b1.add(30);  
           b1.add(70);  
           b1.add(80);  
           b1.preTraverse(b1.root);  
           System.out.println("Find 1 : "+b1.find(1));  
           System.out.println("Find 5 : "+b1.find(5));  
           System.out.println("Delete 30 : "+b1.remove(30));  
           System.out.println("Delete 20 : "+b1.remove(20));  
           System.out.println("Delete 80 : "+b1.remove(80));  
           System.out.println("Delete 10 : "+b1.remove(10));  
           System.out.println("Delete 70 : "+b1.remove(70));  
           System.out.println("Delete 50 : "+b1.remove(50));  
           b1.preTraverse(b1.root);  
      }  
 }  
 class BinaryTree{  
       class Node{  
           int key;  
           Node right;  
           Node left;  
           Node parent;  
           Node(){}  
           Node(int key){  
                this.key=key;  
           }  
           public String toString(){return ""+key;}  
      }  
      Node root;  
      public void add(int val){  
           Node newElement=new Node(val);  
           if(root==null){  
                root=newElement;  
                return;  
           }  
           Node cursorNode=root;  
           while(true){  
                if(val<cursorNode.key){  
                     if(cursorNode.left==null){  
                          cursorNode.left=newElement;  
                          newElement.parent=cursorNode;  
                          return;  
                     }  
                     cursorNode=cursorNode.left;  
                }  
                else if(val>cursorNode.key){  
                     if(cursorNode.right==null){  
                          cursorNode.right=newElement;  
                          newElement.parent=cursorNode;  
                          return;  
                     }  
                     cursorNode=cursorNode.right;  
                }  
           }  
      }  
      //remove operations  
      public boolean remove(int key){  
           Node nodeToDelete=find(key);  
           if(nodeToDelete!=null){  
                //case #1:node has no child.  
                if(nodeToDelete.left==null && nodeToDelete.right==null){  
                     deleteCase1(nodeToDelete);  
                     return true;  
                }//case 2#:node has only one child (right | left).  
                else if(nodeToDelete.left!=null && nodeToDelete.right==null){  
                     deleteCase2(nodeToDelete,true);  
                     return true;  
                }  
                else if(nodeToDelete.right!=null && nodeToDelete.left==null){  
                     deleteCase2(nodeToDelete,false);  
                     return true;   
                }//case 3#:node has two child's.  
                else{  
                     deleteCase3(nodeToDelete);  
                     return true;  
                }  
           }  
           return false;  
      }  
      //delete case #1 method.  
      private void deleteCase1(Node nodeToDelete){  
           if(nodeToDelete==root){  
                root=null;  
                return;  
           }  
           Node parent=nodeToDelete.parent;  
           if(parent.left==nodeToDelete)parent.left=null;  
           else if(parent.right==nodeToDelete)parent.right=null;  
      }  
      //delete case #2 method.  
      private void deleteCase2(Node nodeToDelete,boolean isLeftNode){  
           if(nodeToDelete==root){  
                if(isLeftNode)root=nodeToDelete.left;  
                else root=nodeToDelete.right;  
                return;  
           }  
           Node parent=nodeToDelete.parent;  
           if(parent.left==nodeToDelete){  
                if(isLeftNode)parent.left=nodeToDelete.left;  
                else parent.left=nodeToDelete.right;  
           }else if(parent.right==nodeToDelete){  
                if(isLeftNode)parent.right=nodeToDelete.left;  
                else parent.right=nodeToDelete.right;  
           }  
      }  
      //delete case #2 method.  
      private void deleteCase3(Node nodeToDelete){  
           Node nodeToSwap=minNode(nodeToDelete.right);  
           if(nodeToSwap==nodeToDelete.right)deleteCase2(nodeToSwap,false);  
           else deleteCase1(nodeToSwap);  
           nodeToDelete.key=nodeToSwap.key;  
      }  
      //find operations  
      public Node find(int key){  
           return findNode(root,key);  
      }  
      private Node findNode(Node root,int key){  
           if(root==null)return null;  
           if(root.key==key)return root;  
           if(key<root.key)return findNode(root.left,key);  
           if(key>root.key)return findNode(root.right,key);  
           return null;  
      }  
      private Node minNode(Node root){  
           if(root.left!=null){  
                return minNode(root.left);  
           }else return root;  
      }  
      //traverse operation's.  
      public void inorderTraverse(Node root){  
           if(root!=null){  
                inorderTraverse(root.left);  
                System.out.println(root.key);  
                inorderTraverse(root.right);  
           }  
      }  
      public void postTraverse(Node root){  
           if(root!=null){  
                postTraverse(root.left);  
                postTraverse(root.right);  
                System.out.println(root.key);  
           }  
      }  
      public void preTraverse(Node root){  
           if(root!=null){  
                System.out.println(root.key);  
                preTraverse(root.left);  
                preTraverse(root.right);  
           }  
      }  
 }