二叉查找树中，最复杂的操作就是删除操作。对于叶子节点，直接删除即可。对于一颗子树的节点，用子树取代原节点即可。对于拥有两颗子树的节点，首先用右子树最小的节点取代源节点，再递归删除此最小节点。

具体代码如下所示：

package com.Algorithm.Tree;
import java.util.*;
import java.io.*;
/*
 * author:Tammy Pi
 * function:二叉查找树
 */
public class BiSearchTree {

	public TreeNode root=null;
	private Scanner scanner=null;
	
	public BiSearchTree()
	{
		scanner=new Scanner(System.in);
	}
	public TreeNode getRoot() {
		return root;
	}
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	public Scanner getScanner() {
		return scanner;
	}
	public void setScanner(Scanner scanner) {
		this.scanner = scanner;
	}
	
    public void createTree()
    {
    	this.root=createTree(this.root);
    }
    public void midTraverse()
    {
    	midTraverse(this.root);
    }
    //中序遍历，相当于排序
    public void midTraverse(TreeNode root)
    {
    	if(root!=null)
    	{
    		midTraverse(root.getLchild());
    		System.out.print(root.getData()+" ");
    		midTraverse(root.getRchild());
    	}
    }
	//建立二叉查找树
	public TreeNode createTree(TreeNode root)
	{
		String str=scanner.next();
		int n=Integer.parseInt(str);
		
		for(int i=0;i<n;i++)
		{
			String data=scanner.next();
			if(root==null)
			{
				root=new TreeNode(data);
			}
			else 
			{
				TreeNode node=new TreeNode(data);
				TreeNode x=root,y=root;
				
				while(x!=null)
				{
					if(x.getData().compareTo(node.getData())>0)
					{
						y=x;
						x=x.getLchild();
					}
					else 
					{
						y=x;
						x=x.getRchild();
					}
				}
				if(y.getData().compareTo(node.getData())>0)
				{
					y.setLchild(node);
				}
				else
				{
					y.setRchild(node);
				}
			}
		}//for i
		
		return root;
	}//createTree
	//查找最小的节点
	public TreeNode findMin(TreeNode node)
	{
		TreeNode x=node;
		while(node!=null)
		{
			x=node;
			node=node.getLchild();
		}
		return x;
	}
	public void testRemove()
	{
		root.setRchild(remove(root.getRchild(),root.getRchild()));
		System.out.print("删除节点后，中序遍历结果为：");
	    midTraverse();
	}
	//删除节点
	//node为待删除节点
	public TreeNode remove(TreeNode node,TreeNode subTree)
	{
		if(subTree==null)
		{
			return null;
		}
		
		int state=node.getData().compareTo(subTree.getData());
		if(state<0)
		{
			node.setLchild(remove(node,subTree.getLchild()));
		}
		else if(state>0)
		{
			node.setRchild(remove(node,subTree.getRchild()));
		}
		else if(node.getLchild()!=null&&node.getRchild()!=null)
		{
			TreeNode temp=findMin(node.getRchild());
			node.setData(temp.getData());
			node.setRchild(remove(temp,node.getRchild()));
		}
		else
		{
			node=(node.getLchild()!=null?node.getLchild():node.getRchild());
		}
		return node;
	}
	//用于测试的主函数
	public static void main(String[] args)
	{
		BiSearchTree biTree=new BiSearchTree();
		biTree.createTree();
		System.out.println("查找二叉树建立完成！");
		System.out.print("中序遍历结果为：");
		biTree.midTraverse();
		System.out.println();
		biTree.testRemove();
	}
}