二叉查找树Java的实现

package binarytree;


public class BinarySearchTree<T extends Comparable<? super T>> {
  private static class BinaryNode<T>{
      private T element;
      private BinaryNode<T> left;//左子树
      private BinaryNode<T> right;//右子树
      public BinaryNode(T theElement){
          this( theElement,null,null);
      }
      public BinaryNode(T theElement,BinaryNode<T> lt,BinaryNode<T> rt){
          element=theElement;
          left=lt;
          right=rt;
      }
  }
  private BinaryNode<T> root;
  public BinarySearchTree(){
      root=null;
  }
  public void makeEmpty(){
      root=null;
  }
  public boolean isEmpty(){
      return root==null;
  }
  public boolean contains(T x) {
        return contains(x, root);
    
     }
  public T findMin(){
      if(isEmpty()){
        ;  
      }
      return findMin(root).element;   
  }
  public T findMax(){
     if(isEmpty()){
        ;
     }           
      return findMax(root).element;
  }
  public void insert(T x){
     // root=insert(x,root);//采用递归
      insert1(x);//不采用递归
  }
  public void remove(T x){
     //root=remove(x,root);//删除节点， 采用递归
     boolean isDelete= remove1(x);//删除节点， 不采用递归
     System.out.println(isDelete);
  }
//如果树中含有项X的节点，返回true
  private boolean contains(T x,BinaryNode<T> t){
      if(t==null){
          return false;
      }
      int compareResult=x.compareTo(t.element);
      if(compareResult<0){
          return contains(x, t.left);
      }else if(compareResult>0){
          return contains(x, t.right);
      }else{
          return true;
      }
  }
//如果树中含有项X的节点，返回true(不采用递归)
  public boolean contains1(T x){
      if(root==null){
          return false;
      }
     BinaryNode<T> current=root;
     while(current!=null){
         if((x.compareTo(current.element))>0){
             current=current.right;
         }else if((x.compareTo(current.element))<0){
             current=current.left;
         }else{
             return true;
         }
     }
     return false;
    
  }
//返回树中包含最小元的节点的引用，从根开始并且只要有左儿子就向左进行，终止点点就是最小的元素
  private BinaryNode<T> findMin(BinaryNode<T> t){
     if(t==null){
         return null;
     }else if(t.left==null){
         return t;
     }
     return findMin(t.left);
  }
 
//返回树中包含最大元的节点的引用
  private BinaryNode<T> findMax(BinaryNode<T> t){
    if(t!=null){
        while(t.right!=null){
            t=t.right;
        }
    }
    return t;
  }
//插入方法,t引用该树的根，而根又在第一次插入式变化，因此返回对新树根的引用,采用递归
  private  BinaryNode<T> insert(T x,BinaryNode<T> t){
      if(t==null){
        return new BinaryNode<T>(x,null,null);
      }
      int compareResult=x.compareTo(t.element);
      if(compareResult<0){
          t.left=insert(x,t.left);
      }else if(compareResult>0){
          t.right=insert(x, t.right);
      }else{
          ;//重复元素不添加
      }
      return t;
  }
//插入方法， 不采用递归
  private void insert1(T x){
      BinaryNode<T> newNode=new BinaryNode<T>(x);
     if(root==null){
         root=newNode;
     }else{
       BinaryNode<T> current=root;
       BinaryNode<T> parent = null;
       while(current!=null){//找到插入节点的父节点
           parent=current;
           if((x.compareTo(current.element))>0){//插入节点大于目前节点
               current=current.right;
           }else if((x.compareTo(current.element))<0){
               current=current.left;
           }else{
               return ;//相同节点，什么都不做
           }
       }
       if((x.compareTo(parent.element))>0){
           parent.right=newNode;
       }else if((x.compareTo(parent.element))<0){
           parent.left=newNode;
       }else{
           return ;//相同节点，什么都不做
       }
     }
    
        
 }
  //删除节点，采用递归，返回对根节点的引用
  private BinaryNode<T> remove(T x,BinaryNode<T> t){
      if(t==null){
          return t;
      }
      int compareResult=x.compareTo(t.element);
      if(compareResult<0){
          t.left=remove(x,t.left);
      } else if(compareResult>0){
          t.right=remove(x,t.right);
      }else  if(t.left!=null&&t.right!=null){
          t.element=findMin(t.right).element;
          t.right=remove(t.element, t.right);
      } else {
          t=(t.left!=null)?t.left:t.right;
      }
      return t;
  }
//删除节点， 不采用递归
  private boolean remove1(T x){
     if(root==null){
         return false  ;//若树为空，什么也不做
     }
    BinaryNode<T> current=root;
    BinaryNode<T> parent=null;//parent为要删除节点的父节点
    while((current.element.compareTo(x))!=0){//先找到要删除节点的父节点
        parent =current;
        if(current.element.compareTo(x)>0){//当前节点大于删除节点
            current=current.left;
        }else{
            current=current.right;
        }
        if(current==null){
            return false;//没有找到该节点
        }
    }
    
    //要删除节点不存在左右子树
     if(current.right==null&&current.left==null){
       if(parent!=null){
         if((parent.element.compareTo(current.element))>0){//若父节点的值大于子节点的值
            parent.left=null;
         }else{
            parent.right=null;
         }
        }else{//要删除的为根节点
           root=null;
       }
        return true;
      }
    //要删除节点的右子树不为空
     if(current.left==null&&current.right!=null){
       if(parent!=null){
        if(current==parent.left){
            parent.left=current.right;
        }else{
            parent.right=current.right;
        }
       }else{//要删除的为根节点
           root=current.right;
       }
        return true;
     }
    //要删除节点的左子树有不为空
      if(current.left!=null&&current.right==null){
       if(parent!=null){
         if(current==parent.left){
            parent.left=current.left;
         }else{
            parent.right=current.left;
         }
        }else{//要删除的为根节点
            root=current.left;
        }
        return true;
     }
   //要删除的节点左右节点全都不为空
   //找到该节点右子树的最小节点
    BinaryNode<T> min=this.findMin(current.right);
    this.remove1(min.element);
    current.element=min.element;
    return true;  
  }
 
  public void printTree(){
      if(isEmpty()){
          System.out.println("Empty tree");
      }else{
          printTree(root);
      }
  }
  private void printTree(BinaryNode<T> t){
      if(t!=null){
          printTree(t.left);
          System.out.println(t.element);
          printTree(t.right);
      }
  }
  public void printRoot(){
      if(root==null){
          System.out.println("Empty tree");
      }else{
          System.out.println("root:"+root.element);
      }
  }
 
}