java实现二叉树，以及递归实现前序，中序，后序遍历，非递归实现前序

1.如有不正之处，敬请指正！

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BST<E extends Comparable<E>> {
	
	private class Node{
		E e;
		public Node left;
		public Node right;
		
		public Node(E e) {
			this.e = e;
		}

	
	}
	
	private Node root;
	private int size = 0;
	
	public int getSize() {
		return size;
	}
	
	public boolean isEmpty() {
		return size == 0;
	}
	
	public void add(E e) {                        //先二叉树添加元素
		root=add(root,e);
	}

	private Node add(Node node, E e) {
		if (node == null) {
			node = new Node(e);
			size++;
			return node;
		}
	  if (e.compareTo(node.e)>0) {
		  node.right = add(node.right, e);
	}else if (e.compareTo(node.e)<0) {
		node.left = add(node.left, e);
	}
	  return node;		
	}
	
	
	//
	
	public boolean contain(E e) {                       //查询二叉树是否包含某一元素
	return contain(root,e);
	
}
	
	private boolean contain(Node node, E e) {

		 if (node == null) {
				return false;
		 }
		 if (node.e.compareTo(e) == 0) {
			return true;
		}else if (node.e.compareTo(e)>0) {
			
			return contain(node.left,e);
		}else if (node.e.compareTo(e)<0) {

			return contain(node.right,e);
		
		}else {
			return false;
		}
		
		
	}

	public void preOrder() {                        //前序遍历递归实现
		
	preOrder(root);
		
	}

	private void preOrder(Node node) {                       
		if (node == null) {
			return ;
		}
		System.out.println(node.e);
		 preOrder(node.left);
		 preOrder(node.right);
	}
	
	
	public void preOrderNR() {       //前序遍历非递归写法，用栈实现
		Stack<Node> stack = new  Stack<Node>();
		stack.push(root);
		while(!stack.isEmpty()) {
			Node  nowNode = stack.pop();
			System.out.println(nowNode.e);
			if (nowNode.right != null) {
				stack.push(nowNode.right);
			}
			if (nowNode.left != null) {
				stack.push(nowNode.left);
			}
			
		}
		
	}
	
	public void midOrder() {             //中序遍历递归实现
		midOrder(root);
	}

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

	}

	private void backOrder(Node node) {               //后续遍历递归实现
		
		if (node == null) {
			return;
		}
		backOrder(node.left);
		backOrder(node.right);
		System.out.println(node.e);
		
	}
	
	public void leveOrder() {	                                  //层次遍历， 广度优先搜索
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		
		while(!queue.isEmpty()) {
			Node node = queue.peek();
			queue.remove();
			System.out.println(node.e);
			if (node.left != null) {
				queue.add(node.left);
			}
			if (node.right != null) {
				queue.add(node.right);
			}
			
			
		}
		
	}
	
}