Java学习笔记之数据结构中的树

数据结构中二叉树的代码如下：

package tech2;

public class BTNode<E> {
    private E data;
    private BTNode<E> left;
    private BTNode<E> right;

    public BTNode(E root) {
        data = root;
    }

    /**
     * BTNode<E> 的构造函数
     * 
     * @param data
     *            结点
     * @param left
     *            左子树
     * @param right
     *            右子树
     */
    public BTNode(E data, BTNode<E> left, BTNode<E> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }

    // get 和 set 方法
    public E getData() {
        return data;
    }

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

    public BTNode<E> getLeft() {
        return left;
    }

    public void setLeft(BTNode<E> left) {
        this.left = left;
    }

    public BTNode<E> getRight() {
        return right;
    }

    public void setRight(BTNode<E> right) {
        this.right = right;
    }

    public boolean isLeaf() {
        return (left == null) && (right == null);
    }

    /**
     * 查找从本结点开始的最左结点的数据
     * 
     * @return
     */
    public E getLeftmostData() {
        if (left == null)
            return data;
        else
            return left.getLeftmostData();
    }

    public E getRightmostData() {
        if (right == null)
            return data;
        else
            return right.getRightmostData();
    }

    /**
     * 删除最左结点的方法，当删除时最左结点不可能有两个孩子，否则就递归到下一个了
     * 
     * @return 返回的是比原来小的树的根节点的引用
     */
    public BTNode<E> removeLeftmost() {
        if (left == null)
            return right; // 最右边的结点在根处，因为没有左孩子
        else {
            left = left.removeLeftmost(); // 从这里开始递归了
            return this; // 到这里是完成，并且返回
        }
    }

    public BTNode<E> removeRightmost() {
        if (right == null)
            return right;
        else {
            right = right.removeRightmost();
            return this;
        }
    }

    /**
     * 递归复制一个树
     * 
     * @param source
     *            要被复制的树
     * @return 返回的是一个新树的对象
     */
    public static <E> BTNode<E> treeCopy(BTNode<E> source) {
        BTNode<E> leftCopy, rightCopy;
        if (source == null)
            return null;
        else {
            leftCopy = treeCopy(source.left);
            rightCopy = treeCopy(source.right);
            return new BTNode<E>(source.data, leftCopy, rightCopy);
        }
    }

    /**
     * 前序遍历
     */
    public void preorderPrint() {
        System.out.println(data);
        if (left != null)
            left.preorderPrint();
        if (right != null)
            right.preorderPrint();
    }

    /**
     * 中序遍历
     */
    public void inorderPrint() {
        if (left != null)
            left.inorderPrint();
        System.out.println(data);
        if (right != null)
            right.inorderPrint();
    }

    /**
     * 后序遍历
     */
    public void postorderPrint() {
        if (left != null)
            left.postorderPrint();
        if (right != null)
            right.postorderPrint();
        System.out.println(data);
    }

    public void print(int depth) {
        int i;
        // 打印缩进和当前结点中的数据
        for (i = 1; i <= depth; i++)
            System.out.println("  ");
        System.out.println(data);
        // 打印左子树
        if (left != null)
            left.print(depth + 1);
        else if (right != null) {
            for (i = 1; i <= depth + 1; i++)
                System.out.println("  ");
            System.out.println("--");
        }

        // 打印右子树
        if (right != null)
            right.print(depth + 1);
        else if (left != null) {
            for (i = 1; i <= depth; i++)
                System.out.println("  ");
            System.out.println("--");
        }
    }

    /**
     * 统计树共有多少个结点
     * 
     * @param root
     * @return 返回结点数
     */
    public static <E> int treeSize(BTNode<E> root) {
        if (root == null)
            return 0;
        else
            return 1 + treeSize(root.left) + treeSize(root.right);
    }

    /**
     * 二叉树的深度递归算法
     * 
     * @param root
     * @return 返回树的深度
     */
    public static <E> int depth(BTNode<E> root) {
        if (root == null)
            return 0;
        else {
            int m = depth(root.left);
            int n = depth(root.right);

            // 树的深度每次依靠这个三目运算符后加一来递增的
            return (m > n ? m : n) + 1;
        }
    }

}