二叉树返回节点个数、层数，层序遍历

/**
 * BST树的节点类型
 * @param <T>
 */
class BSTNode <T extends Comparable<T>>{
    private T data; // 数据域
    private BSTNode<T> left; // 左孩子域
    private BSTNode<T> right; // 右孩子域

    public BSTNode(T data, BSTNode<T> left, BSTNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public BSTNode<T> getLeft() {
        return left;
    }

    public void setLeft(BSTNode<T> left) {
        this.left = left;
    }

    public BSTNode<T> getRight() {
        return right;
    }

    public void setRight(BSTNode<T> right) {
        this.right = right;
    }
}

/**
 * BST树的实现
 * @param <T>
 */
class BST<T extends Comparable<T>>{
    private BSTNode<T> root; // 指向根节点

    /**
     * BST树的初始化
     */
    public BST() {
        this.root = null;
    }

/**
     * 返回个数
     * @return
     */
    public int number(){
        return number(this.root);
    }
    private int number(BSTNode root){
        if (root == null){
            return  0;
        }else {
         return number(root.getLeft())+ number(root.getRight())+1;
        }
    }

    /**
     * 返回层数
     * @return
     */
    public int level(){
        return Level(this.root);
    }
    private int Level(BSTNode<T> root) {
        if (root == null){
            return 0;
        }else {
            int left = Level(root.getLeft());
            int right = Level(root.getRight());
            return left > right ? left+1:right+1;
        }
    }

    /**
     * 层序遍历
     */
    public void levelOrder(){
        int hight = level();
        System.out.print("递归层序遍历：");
        for (int i = 0; i < hight; i++) {
            levelOrder(this.root,i);
        }
    }
    private void levelOrder(BSTNode<T> root, int i) {
        if (root!= null){
            if (i==0){
                System.out.print(root.getData()+"  ");
            }
            levelOrder(root.getLeft(),i-1);
            levelOrder(root.getRight(),i-1);
        }
    }
 }