利用笛卡尔坐标系在控制台画出二叉树

思想

二叉树的概念就不说了，怎样把二叉树画出来，像课本上那样的。
在控制如画的话，就是在一个纯文本的环境下了。
整个控制如可以看作是一个笛卡尔坐标系。
通过给树的结点设置x y 坐标
- 计算x时即按照每行有 2^x 个元素，从root开始，下一行的左右结点的位置位于父结点的左右两边。
计算y时需要使用一开始创建树的时候设置好的树的层级 level 属性。

从而能够在控制台画出二叉树。

树的结点定义

/**
 * 
 * @auther wuwang
 * @createTime 2015-6-17 下午11:17:04
 */
package tree.binarytree;

import lombok.Data;

/**
 * 
 * 
 * @author peaches
 */
@Data
public class BinaryTree {
    private Node root;

    /* 二叉树的构造方法 */
    public BinaryTree() {
        root = null;
    }

    /* insert方法 */
    public void insert(int data) {

        root = insert(root, data, null);
    }

    public Node insert(Node node, int data, Node nodeParent) {
        if (node == null) {
            node = new Node(data);
            node.parent = nodeParent;
            node.level = countLevel(node);
        } else {
            if (data <= node.data) {
                node.left = insert(node.left, data, node);// 递归这里的insert，才形成
                // 的树，其实是二叉排序树。
            } else {
                node.right = insert(node.right, data, node);
            }
        }
        return node;

    }

    /* 构建二叉树 */
    public BinaryTree buildTree(int... a) {
        for (int data : a) {
            insert(data);
        }
        return this;
    }

    /* 下面就是中序遍历啊 */
    public void printTree() {
        printTree(root);
        /* System.out.println(); */
    }

    public void printTree(Node node) {
        if (node == null) {
            return;
        }
        printTree(node.left);
        System.out.println(node.data + "");
        printTree(node.right);
    }

    public int countLevel(Node node) {
        return node == null ? 0 : (1 + countLevel(node.parent));
    }

    /* 定义一个静态内部类，Node节点 */
    @Data
    public static class Node {
        Node parent;// 父结点
        Node left;// 左结点
        Node right;// 右结点
        int x;// 用于画图，图形中的位置，横坐标
        int y;// 用于画图，图形中的位置，纵坐标
        Integer data;// 结点的值
        int level;// 从root到此结点的层级

        public Node getParent() {
            return null;// toString()时忽略父结点，避免lombok生成的代码会递归溢出
        }

        Node(Integer newData) {
            left = null;
            right = null;
            data = newData;
        }
    }
}

定义一个工具类，用于输出二叉树结点

/**
 * 
 * @auther wuwang
 * @createTime 2015-6-17 下午11:31:52
 */
package tree.binarytree;

import java.util.Arrays;

/**
 * 
 * 
 * @author peaches
 */
public class BinaryTreeUtils {

    private static int nodeNum;
    private static int lineLength;
    private static int maxLevel;
    private static String[][] strings;

    /**
     * 绘制二叉树
     * 
     * @param binaryTree
     * @createTime 2015-6-19 上午7:55:57
     */
    public static void drawBinaryTree(BinaryTree binaryTree) {

        nodeNum = countNode(binaryTree.getRoot());

        lineLength = nodeNum * 2;

        beforeDrawBinaryTree(binaryTree.getRoot(), NodePostion.ROOT);

        strings = new String[maxLevel + 1][lineLength * 2];

        for (int i = 0; i < strings.length; i++) {
            for (int j = 0; j < strings[i].length; j++) {
                strings[i][j] = " ";
            }
        }

        System.out.println("nodeNum: " + nodeNum);

        drawBinaryTree(binaryTree.getRoot());

        System.out.println("------------------------------------");

        for (String[] s : strings) {
            System.out.println(Arrays.toString(s).replaceAll("[\\]\\[\\,]{1}", " "));
        }
    }

    /**
     * 绘制二叉树前，先计算二叉树中所有结点在xy坐标系中的位置
     * 
     * @param node
     * @param nodePostion
     * @createTime 2015-6-19 上午7:53:59
     */
    private static void beforeDrawBinaryTree(BinaryTree.Node node, NodePostion nodePostion) {
        if (node == null) {
            return;
        }
        countXY(node, nodePostion);

        if (node.left == null) {
            node.left = new BinaryTree.Node(null);
            node.left.parent = node;
            node.left.level = node.level + 1;
            countXY(node.left, NodePostion.LEFT);
        } else {
            beforeDrawBinaryTree(node.left, NodePostion.LEFT);
        }

        if (node.right == null) {
            node.right = new BinaryTree.Node(null);
            node.right.parent = node;
            node.right.level = node.level + 1;
            countXY(node.right, NodePostion.RIGHT);
        } else {
            beforeDrawBinaryTree(node.right, NodePostion.RIGHT);
        }
    }

    /**
     * 绘制二叉树，把二叉树的所有结点输出到一个二维数组中。二维数组即代表终端，用于按行输出
     * 
     * @param node
     * @createTime 2015-6-19 上午7:55:01
     */
    private static void drawBinaryTree(BinaryTree.Node node) {
        if (node == null) {
            return;
        }
        strings[node.y][node.x] = String.valueOf(node.data);
        drawBinaryTree(node.left);
        drawBinaryTree(node.right);
    }

    /**
     * 计算二叉树结点个数
     * 
     * @param node
     * @return
     * @createTime 2015-6-17 下午11:45:33
     */
    private static int countNode(BinaryTree.Node node) {
        if (node == null) {
            return 0;
        }
        return 1 + countNode(node.left) + countNode(node.right);
    }

    /**
     * 计算二叉树结点在xy坐标系中的坐标
     * 
     * @param node
     * @param nodePostion
     * @createTime 2015-6-19 上午7:53:30
     */
    private static void countXY(BinaryTree.Node node, NodePostion nodePostion) {

        int x = 0;
        int y = 0;
        switch (nodePostion) {
        case LEFT:
            x = (int) (node.parent.x - lineLength / (Math.pow(2, node.level) + 2));
            y = node.level;
            break;
        case RIGHT:
            x = (int) (node.parent.x + lineLength / (Math.pow(2, node.level) + 2));
            y = node.level;
            break;
        case ROOT:
            x = lineLength / 2;
            y = node.level;
            break;
        }
        node.x = x;
        node.y = y;
        if (maxLevel < node.level) {
            maxLevel = node.level;
        }
    }

    /**
     * 结点位置，左，右，根
     * 
     * @author peaches
     */
    public static enum NodePostion {
        LEFT, RIGHT, ROOT
    }
}

调用

/**
 * 
 * @auther wuwang
 * @createTime 2015-6-17 下午11:17:45
 */
package tree.binarytree;

/**
 * 
 * 
 * @author peaches
 */
public class TreeMain {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree().buildTree(0, 8, 23, 10, 48, 12, 13, 1, 2, 3, 42, 675, 826, 7, 0, 8, 23, 10, 48, 12, 13, 1, 2, 3, 42, 675, 826, 7);
        System.out.println(binaryTree);

        BinaryTreeUtils.drawBinaryTree(binaryTree);
    }
}