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);
}
}