二叉搜索树

节点类：

包含自身值element和左节点left和右节点right的一个嵌套类

		private static class BinaryNode{
		public int element;
		public BinaryNode left;
		public BinaryNode right;
		public BinaryNode(int a) {
			this(a,null,null);
		}
		public BinaryNode(int a,BinaryNode b,BinaryNode c) {
			element = a;
			left = b;
			right = c;
		}
	}

插入：

对当前节点进行插入，通过插入值与当前节点的值进行比较，如果小于当前节点则对当前节点的left子树进行插入，并将插入后的left子树赋值给当前节点的left子节点。大于则相反。如果为空则创建一个新的节点作为树。

		private BinaryNode insert(int a,BinaryNode t) {
		if(t==null) {
			return new BinaryNode(a);
		}
		if(a<t.element) {
			t.left=insert(a, t.left);
		}else if(a>t.element) {
			t.right=insert(a, t.right);
		}
		return t;
	}

---

删除：

将要删除的值与当前节点的值进行比较，如果要删除的值大于当前节点的值，则在right子树中删除，并将删除后的right子树重新赋值给当前节点的右子树。小于则相反。
对于等于则有种情况：
如果当前节点只有一个子节点，则删除当前节点，并将子节点赋值给父节点相应的子节点。
如果当前节点有两个节点，则将当前节点的right子树的最小值赋值给当前节点，再将right子树最小值删除，重新赋值给当前节点的right节点。

	private BinaryNode remove(int a,BinaryNode t) {
		if(t==null) {
			return t;
		}
		if(a<t.element) {
			t.left= remove(a, t.left);
		}else if(a>t.element) {
			t.right= remove(a, 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 contains(int a,BinaryNode t) {
		if(t==null) {
			return false;
		}
		if(a<t.element) {
			return contains(a, t.left);
		}else if(a>t.element){
			return contains(a, t.right);
		}else {
			return true;
		}
	}

---

二叉搜索树类：

public class BinarySerchTree{
	
	private BinaryNode root;
	
	public void insert(int a) {
		root = insert(a, root);
	}
	
	public void remove(int x) {
		root = remove(x, root);
	}
	
	public Boolean contains(int a) {
		return contains(a, root);
	}
	
	public Boolean isEmpty() {
		return root==null;
	}
	
	public int findMin() throws Exception {
		if(isEmpty()) {
			throw new Exception();
		}else {
			return findMin(root).element;
		}
	}
	private boolean contains(int a,BinaryNode t) {
		if(t==null) {
			return false;
		}
		if(a<t.element) {
			return contains(a, t.left);
		}else if(a>t.element){
			return contains(a, t.right);
		}else {
			return true;
		}
	}

	private BinaryNode insert(int a,BinaryNode t) {
		if(t==null) {
			return new BinaryNode(a);
		}
		if(a<t.element) {
			t.left=insert(a, t.left);
		}else if(a>t.element) {
			t.right=insert(a, t.right);
		}
		return t;
	}
	
	private BinaryNode findMin(BinaryNode t) {
		if(t==null) {
			return null;
		}else if(t.left==null){
			return t;
		}else {
			return findMin(t.left);
		}
	}
	
	private BinaryNode findMax(BinaryNode t) {
		if(t==null) {
			return null;
		}else if(t.right==null){
			return t;
		}else {
			return findMax(t.right);
		}
	}
	
	private BinaryNode remove(int a,BinaryNode t) {
		if(t==null) {
			return t;
		}
		if(a<t.element) {
			t.left= remove(a, t.left);
		}else if(a>t.element) {
			t.right= remove(a, 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 static class BinaryNode{
		public int element;
		public BinaryNode left;
		public BinaryNode right;
		public BinaryNode(int a) {
			element=a;
			left=null;
			right=null;
		}
		public BinaryNode(int a,BinaryNode b,BinaryNode c) {
			element = a;
			left = b;
			right = c;
		}
	}

}