二叉搜索树

public class BinarySearchTree {
    //内部类，代表二叉搜索树的一个节点
    private class TreeNode{
        int element;
        TreeNode left;
        TreeNode right;
    }
//  //递归搜索查找
//  public TreeNode Find(int x,TreeNode T){
//      if(T==null){
//          return null;
//      }
//      if(x<T.element){
//          return Find(x,T.left);
//      }else if(x>T.element){
//          return Find(x,T.right);
//      }else{
//          return T;
//      }
//  }
    //非递归搜索查找
    public TreeNode Find(int x,TreeNode T){
        if(T!=null){
            if(x<T.element){
                while(T.left!=null){
                    T=T.left;
                }
            }else{
                while(T.right!=null){
                    T=T.right;
                }
            }
        }
        return T;
    }
//  //递归的方式查找最小值
//  public TreeNode FindMin(TreeNode T){
//      if(T==null){
//          return null;
//      }else if(T.left==null){
//          return T;
//      }else{
//          return FindMin(T.left);
//      }
//  }
    //非递归的方式查找最小值
    public TreeNode FindMin(TreeNode T){
        if(T!=null){
            while(T.left!=null){
                T=T.left;
            }
        }
        return T;
    }
//  //递归的方式查找最大值
//  public TreeNode FindMax(TreeNode T){
//      if(T==null){
//          return null;
//      }else if(T.right==null){
//          return T;
//      }else{
//          return FindMin(T.right);
//      }
//  }
    //非递归的方式查找最大值
    public TreeNode FindMax(TreeNode T){
        if(T!=null){
            while(T.right!=null){
                T=T.right;
            }
        }
        return T;
    }
    /*
     * 二叉搜索树的插入规则：
     * 1. 如果插入前该树无任何节点，则将该节点插到根节点
     * 2. 如果该树小于要插入位置的父节点，则递归插入到该父节点的左子节点
     * 3. 如果该树大于要插入位置的父节点，则递归插入到该父节点的右子节点
     * 4. 最后将插入后的树节点返回
     */
    public TreeNode Insert(int x,TreeNode T){
        if(T==null){
            T.element=x;
            T.left=T.right=null;
        }else if(x<T.element){
            T.left=Insert(x,T.left);
        }else if(x>T.element){
            T.right=Insert(x,T.right);
        }
        return T;
    }
    /*
     * 二叉搜索树的删除规则：
     * 1. 如果节点是叶节点，则立即删除
     * 2. 如果节点有一个子节点，则删除该节点后，其子节点代替父节点（被删除的节点）的位置 
     * 3. 如果节点有两个子节点，则用其右子树的最小数据代替该节点的数据并递归地删除那个节点
     */
    public TreeNode Delete(int x,TreeNode T){
        TreeNode TmpCell;
        if(T==null){
            return null;
        }else if(x<T.element){    //如果小于该节点值，则递归删除其左子节点
            T.left=Delete(x,T.left);
        }else if(x>T.element){   //如果大于该节点值，则递归删除其右子节点
            T.right=Delete(x,T.right);
        }else if(T.left!=null&&T.right!=null){ //若被删除的节点有左右子节点，则将其右子树的最小数据代替该节点的数据，并递归删除该节点
            TmpCell=FindMin(T.right);
            T.element=TmpCell.element;
            T.right=Delete(T.element,T.right);
        }else{        //若被删除的节点只有一个子节点或者为叶节点
            TmpCell=T;
            if(T.left==null){
                T=T.right;
            }else if(T.right==null){
                T=T.left;
            }
            TmpCell=null;
        }
        return T;
    }
}