思想
二叉树的概念就不说了，怎样把二叉树画出来，像课本上那样的。
在控制如画的话，就是在一个纯文本的环境下了。
整个控制如可以看作是一个笛卡尔坐标系。
通过给树的结点设置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);
}
}时间： 2024-10-10 23:22:52