数据结构——二分搜索树的实现

public class BST<E extends Comparable<E>> {
	private class Node{
		public E e;
		public Node left,right;
		//构造函数，让用户传入的参数e等于这里的e
		public Node(E e){
			this.e=e;
			left=null;
			right=null;
		}

	}
private Node root;
private  int size;
public BST(){
	root=null;
	size=0;
}
public int size(){
	return size;
}
public boolean isEmpty(){
	return size==0;
}
//向二分搜索树中添加新的元素e
	public void add(E e){
	if(root==null){
		root=new Node(e);
		size++;
	}
	else add(root,e);
	}
      //向以node为根的二分搜索树递归的添加元素e
	private void add(Node node, E e) {
	   if(e.equals(node.e))
	   	return ;
	   else if(e.compareTo(node.e)<0&&node.left==null){
	   	node.left=new Node(e);
	   	size++;
	   	return ;
	   }
	   //以上是递归终止条件
	   else if(e.compareTo(node.e)>0&&node.right==null){
	   	node.right=new Node(e);
	   	size++;
	   	return;
	   }
	   else if(e.compareTo(node.e)<0){
	   	add(node.left,e);
	   }
	   else{
	   	add(node.right,e);
	   }
	}
	//查询是否含有元素e
	public boolean contains(E e){
	    return contains(root,e);
	}

	private boolean contains(Node node, E e) {
	  if(node==null)    return false;
	  if(e.compareTo(node.e)==0)   return true;
	  else if(e.compareTo(node.e)<0)
	  	return contains(node.left,e);
	  else
	  	return contains(node.right,e);
	}
	//前序遍历这个二叉树
	public void preOrder(){
	    preOrder(root);
	}

	private void preOrder(Node root) {
	   if(root==null)   return;
		System.out.println(root.e);
		preOrder(root.left);
		preOrder(root.right);
	}
	public void inOrder(){
		inOrder(root);
	}

	// 中序遍历以node为根的二分搜索树, 递归算法
	private void inOrder(Node node){
		if(node == null)
			return;

		inOrder(node.left);
		System.out.println(node.e);
		inOrder(node.right);
	}

	// 二分搜索树的后序遍历
	public void postOrder(){
		postOrder(root);
	}

	// 后序遍历以node为根的二分搜索树, 递归算法
	private void postOrder(Node node){
		if(node == null)
			return;

		postOrder(node.left);
		postOrder(node.right);
		System.out.println(node.e);
	}
}