java 的简易二叉树的实现

    这学期一直在看数据结构预算法，最近心血来潮，想通过Java来实现一个简单的二叉树，并且实现三种遍历方式。通过这100多行的代码，不仅可以温习二叉树理论，而且将Java中的静态内部类，集合，构造方法等内容进行温习，而且还着重涉及到非常重要的算法——递归。虽然网上有很多关于这个的代码，但是自己写还是会对整个数据结构的理解提升一个层次。下面是我写的代码。希望大家多多批评指正下面代码中的不足之处，谢谢！！

package 二叉树;

import java.util.ArrayList;
import java.util.List;
//import 二叉树.Tree.node;

public class Tree<E> {
	//创立节点node,进行静态内部类创建
    public static class node{
    	node left;
    	node right;
    	Object data;
    	public node() {
    		
    	}
    	public node(Object data) {
    		this.data = data;
    	}
    	public node(Object data,node left,node right) {
    		this.data=data;
    		this.left=left;
    		this.right = right;
    	}
    }
    //下面是创立根节点的方法；
    //先声明一个root,以此作为根节点
    private  node root;
    //空参
    public Tree() {
    	this.root = new node();
    }
    //有参
    public Tree(E data) {
    	this.root = new node(data);
    }
    //对二叉树进行元素添加
    public node addnode(E data,node parent,boolean addleft) {
    	//父节点为空处理
    	if(parent==null) {
    		throw new RuntimeException("父节点不存在添加有误，无法添加");
    	}
    	if(addleft&&parent.left!=null) {
    		throw new RuntimeException("左节点元素已存在，无法添加");
    	}
    	if(!addleft&&parent.right!=null) {
    		throw new RuntimeException("右节点元素已经存在，无法添加");
    	}
    	node nodes = new node(data);
    	if(addleft) {
    		parent.left = nodes;
    	}
    	else {
    		parent.right = nodes;
    	}
    	return nodes;
    }
    //判断二叉树是否为空，即考虑根节点有没有元素
    public boolean isempty() {
    	return root.data==null;
    }
    //访问根节点
    public node root() {
    	if(isempty())
    		throw new RuntimeException("没有根节点");
    	return root;
    }
    //访问父节点的左孩子和右孩子
    public node leftchild(node parent) {
    	return parent.left;
    }
    public node rightchild(node parent) {
    	return parent.right;
    }

    public static int deepth(node nodes) {
    	if(nodes==null)
    		return 0;
    	else if(nodes.left==null && nodes.right==null)
    		return 1;
    	else {
    		//使用递归的方法进行计算
    		int leftdeepth = deepth(nodes.left);
    		int rightdeepth = deepth(nodes.right);
    		int max ;
    		if(leftdeepth>=rightdeepth)
    			max= leftdeepth;
    		else
    			max = rightdeepth;
    		return max+1;
    	}
    }
    //求二叉树的深度
    public int rootdeepth() {
    	return deepth(root);
    }
    /*
     * 接下来就要进行二叉树的遍历，包括前序遍历，后序遍历，中序遍历
     * */
    //前序遍历
    public static List<node> preordertraversal (node nodes) {
    	List<node>list = new ArrayList<node>();
    	list.add(nodes);
    	//使用递归，这一步很关键，没看懂最好多看几遍！！！
    	if(nodes.left!=null)
    		list.addAll(preordertraversal(nodes.left));
    	if(nodes.right!=null)
    		list.addAll(preordertraversal(nodes.right));
    	return list;
    }
    public List<node> allpreordertraversal(){
    	return preordertraversal(root);
    }
    //中序遍历  左根右
    public List<node> midorderTraverse(){
    	         return midTraverse(root);
    	     }
    private List<node> midTraverse(node node){
                List<node> list = new ArrayList<node>();
    	        if(node.left != null)
    	             list.addAll(midTraverse(node.left));
    	        list.add(node);
    	         if(node.right != null)
    	            list.addAll(midTraverse(node.right));
    	         return list;
    	     }
    	     
    	     //后序遍历  左右根
    public List<node> postTraverse(){
    	         return post_Traverse(root);
    	         }
    private List<node> post_Traverse(node node){
    	        	List<node> list = new ArrayList<node>();
    	        	     if(node.left != null)
    	        	          list.addAll(post_Traverse(node.left));
    	        	     if(node.right != null)
    	        	          list.addAll(post_Traverse(node.right));
    	        	          list.add(node);
    	        	         return list;
    	        	     }
    	     }