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

思想

二叉树的概念就不说了，如何把二叉树画出来，像课本上那样的。
在控制如画的话，就是在一个纯文本的环境下了。
整个控制如可以看作是一个笛卡尔坐标系。

通过给树的结点设置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);
    }
}