public void printPreety() {
List<TreeNode> list = new ArrayList<TreeNode>();
list.add(head);
printTree(list, getHeight(head));
}
public int getHeight(TreeNode head) {
if (head == null) {
return 0;
} else {
return 1 + Math.max(getHeight(head.left), getHeight(head.right));
}
}
/**
* pass head node in list and height of the tree
*
* @param levelNodes
* @param level
*/
private void printTree(List<TreeNode> levelNodes, int level) {
List<TreeNode> nodes = new ArrayList<TreeNode>();
//indentation for first node in given level
printIndentForLevel(level);
for (TreeNode treeNode : levelNodes) {
//print node data
System.out.print(treeNode == null?" ":treeNode.data);
//spacing between nodes
printSpacingBetweenNodes(level);
//if its not a leaf node
if(level>1){
nodes.add(treeNode == null? null:treeNode.left);
nodes.add(treeNode == null? null:treeNode.right);
}
}
System.out.println();
if(level>1){
printTree(nodes, level-1);
}
}
private void printIndentForLevel(int level){
for (int i = (int) (Math.pow(2,level-1)); i >0; i--) {
System.out.print(" ");
}
}
private void printSpacingBetweenNodes(int level){
//spacing between nodes
for (int i = (int) ((Math.pow(2,level-1))*2)-1; i >0; i--) {
System.out.print(" ");
}
}
Prints Tree in following format:
4
3 7
1 5 8
2 10
9
package com.tomac120.NodePrinter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* Created by elijah on 6/28/16.
*/
public class NodePrinter{
final private List<List<PrintableNodePosition>> nodesByRow;
int maxColumnsLeft = 0;
int maxColumnsRight = 0;
int maxTitleLength = 0;
String sep = " ";
int depth = 0;
public NodePrinter(PrintableNode rootNode, int chars_per_node){
this.setDepth(rootNode,1);
nodesByRow = new ArrayList<>(depth);
this.addNode(rootNode._getPrintableNodeInfo(),0,0);
for (int i = 0;i<chars_per_node;i++){
//sep += " ";
}
}
private void setDepth(PrintableNode info, int depth){
if (depth > this.depth){
this.depth = depth;
}
if (info._getLeftChild() != null){
this.setDepth(info._getLeftChild(),depth+1);
}
if (info._getRightChild() != null){
this.setDepth(info._getRightChild(),depth+1);
}
}
private void addNode(PrintableNodeInfo node, int level, int position){
if (position < 0 && -position > maxColumnsLeft){
maxColumnsLeft = -position;
}
if (position > 0 && position > maxColumnsRight){
maxColumnsRight = position;
}
if (node.getTitleLength() > maxTitleLength){
maxTitleLength = node.getTitleLength();
}
List<PrintableNodePosition> row = this.getRow(level);
row.add(new PrintableNodePosition(node, level, position));
level++;
int depthToUse = Math.min(depth,6);
int levelToUse = Math.min(level,6);
int offset = depthToUse - levelToUse-1;
offset = (int)(Math.pow(offset,Math.log(depthToUse)*1.4));
offset = Math.max(offset,3);
PrintableNodeInfo leftChild = node.getLeftChildInfo();
PrintableNodeInfo rightChild = node.getRightChildInfo();
if (leftChild != null){
this.addNode(leftChild,level,position-offset);
}
if (rightChild != null){
this.addNode(rightChild,level,position+offset);
}
}
private List<PrintableNodePosition> getRow(int row){
if (row > nodesByRow.size() - 1){
nodesByRow.add(new LinkedList<>());
}
return nodesByRow.get(row);
}
public void print(){
int max_chars = this.maxColumnsLeft+maxColumnsRight+1;
int level = 0;
String node_format = "%-"+this.maxTitleLength+"s";
for (List<PrintableNodePosition> pos_arr : this.nodesByRow){
String[] chars = this.getCharactersArray(pos_arr,max_chars);
String line = "";
int empty_chars = 0;
for (int i=0;i<chars.length+1;i++){
String value_i = i < chars.length ? chars[i]:null;
if (chars.length + 1 == i || value_i != null){
if (empty_chars > 0) {
System.out.print(String.format("%-" + empty_chars + "s", " "));
}
if (value_i != null){
System.out.print(String.format(node_format,value_i));
empty_chars = -1;
} else{
empty_chars = 0;
}
} else {
empty_chars++;
}
}
System.out.print("\n");
int depthToUse = Math.min(6,depth);
int line_offset = depthToUse - level;
line_offset *= 0.5;
line_offset = Math.max(0,line_offset);
for (int i=0;i<line_offset;i++){
System.out.println("");
}
level++;
}
}
private String[] getCharactersArray(List<PrintableNodePosition> nodes, int max_chars){
String[] positions = new String[max_chars+1];
for (PrintableNodePosition a : nodes){
int pos_i = maxColumnsLeft + a.column;
String title_i = a.nodeInfo.getTitleFormatted(this.maxTitleLength);
positions[pos_i] = title_i;
}
return positions;
}
}
NodeInfo类
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public class PrintableNodeInfo {
public enum CLI_PRINT_COLOR {
RESET("\u001B[0m"),
BLACK("\u001B[30m"),
RED("\u001B[31m"),
GREEN("\u001B[32m"),
YELLOW("\u001B[33m"),
BLUE("\u001B[34m"),
PURPLE("\u001B[35m"),
CYAN("\u001B[36m"),
WHITE("\u001B[37m");
final String value;
CLI_PRINT_COLOR(String value){
this.value = value;
}
@Override
public String toString() {
return value;
}
}
private final String title;
private final PrintableNode leftChild;
private final PrintableNode rightChild;
private final CLI_PRINT_COLOR textColor;
public PrintableNodeInfo(String title, PrintableNode leftChild, PrintableNode rightChild){
this(title,leftChild,rightChild,CLI_PRINT_COLOR.BLACK);
}
public PrintableNodeInfo(String title, PrintableNode leftChild, PrintableNode righthild, CLI_PRINT_COLOR textColor){
this.title = title;
this.leftChild = leftChild;
this.rightChild = righthild;
this.textColor = textColor;
}
public String getTitle(){
return title;
}
public CLI_PRINT_COLOR getTextColor(){
return textColor;
}
public String getTitleFormatted(int max_chars){
return this.textColor+title+CLI_PRINT_COLOR.RESET;
/*
String title = this.title.length() > max_chars ? this.title.substring(0,max_chars+1):this.title;
boolean left = true;
while(title.length() < max_chars){
if (left){
title = " "+title;
} else {
title = title + " ";
}
}
return this.textColor+title+CLI_PRINT_COLOR.RESET;*/
}
public int getTitleLength(){
return title.length();
}
public PrintableNodeInfo getLeftChildInfo(){
if (leftChild == null){
return null;
}
return leftChild._getPrintableNodeInfo();
}
public PrintableNodeInfo getRightChildInfo(){
if (rightChild == null){
return null;
}
return rightChild._getPrintableNodeInfo();
}
}
NodePosition类
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public class PrintableNodePosition implements Comparable<PrintableNodePosition> {
public final int row;
public final int column;
public final PrintableNodeInfo nodeInfo;
public PrintableNodePosition(PrintableNodeInfo nodeInfo, int row, int column){
this.row = row;
this.column = column;
this.nodeInfo = nodeInfo;
}
@Override
public int compareTo(PrintableNodePosition o) {
return Integer.compare(this.column,o.column);
}
}
最后，节点接口
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public interface PrintableNode {
PrintableNodeInfo _getPrintableNodeInfo();
PrintableNode _getLeftChild();
PrintableNode _getRightChild();
}
class treeNode{
int key;
treeNode left;
treeNode right;
public treeNode(int key){
this.key = key;
left = right = null;
}
public void printNode(StringBuilder output, String dir){
output.append("<node key='" + key + "' dir='" + dir + "'>");
if(left != null)
left.printNode(output, "l");
if(right != null)
right.printNode(output, "r");
output.append("</node>");
}
}
class tree{
private treeNode treeRoot;
public tree(int key){
treeRoot = new treeNode(key);
}
public void insert(int key){
insert(treeRoot, key);
}
private treeNode insert(treeNode root, int key){
if(root == null){
treeNode child = new treeNode(key);
return child;
}
if(key < root.key)
root.left = insert(root.left, key);
else if(key > root.key)
root.right = insert(root.right, key);
return root;
}
public void saveTreeAsXml(){
StringBuilder strOutput = new StringBuilder();
strOutput.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
treeRoot.printNode(strOutput, "root");
try {
PrintWriter writer = new PrintWriter("C:/tree.xml", "UTF-8");
writer.write(strOutput.toString());
writer.close();
}
catch (FileNotFoundException e){
}
catch(UnsupportedEncodingException e){
}
}
}
这是测试它的代码：
tree t = new tree(1);
t.insert(10);
t.insert(5);
t.insert(4);
t.insert(20);
t.insert(40);
t.insert(30);
t.insert(80);
t.insert(60);
t.insert(50);
t.saveTreeAsXml();
输出看起来像这样：
4
根据VasyaNovikov回答 . 改进了一些Java魔术：泛型和功能界面 .
/**
* Print a tree structure in a pretty ASCII fromat.
* @param prefix Currnet previx. Use "" in initial call!
* @param node The current node. Pass the root node of your tree in initial call.
* @param getChildrenFunc A {@link Function} that returns the children of a given node.
* @param isTail Is node the last of its sibblings. Use true in initial call. (This is needed for pretty printing.)
* @param <T> The type of your nodes. Anything that has a toString can be used.
*/
private <T> void printTreeRec(String prefix, T node, Function<T, List<T>> getChildrenFunc, boolean isTail) {
String nodeName = node.toString();
String nodeConnection = isTail ? "└── " : "├── ";
log.debug(prefix + nodeConnection + nodeName);
List<T> children = getChildrenFunc.apply(node);
for (int i = 0; i < children.size(); i++) {
String newPrefix = prefix + (isTail ? " " : "│ ");
printTreeRec(newPrefix, children.get(i), getChildrenFunc, i == children.size()-1);
}
}
22 回答
我已经创建了简单的二叉树打印机 . 您可以根据需要使用和修改它，但无论如何它都没有进行优化 . 我认为这里可以改进很多东西;）
输出1：
输出2：
按行打印[大]树 .
输出示例：
码：
附：对不起，这个答案并不完全集中在“二元”树上 . 在请求打印树时，它只是用Google搜索 . 解决方案的灵感来自linux中的“tree”命令 .
将打印：
输入
8 4 12 2 6 10 14 1 3 5 7 9 11 13 20 15
这是@ anurag的答案的一个变种 - 看到额外的问题让我烦恼
我为此做了一个改进的算法，它可以很好地处理不同大小的节点 . 它使用线条自上而下打印 .
要将此用于树，请让
Node类实现PrintableNode.输出示例：
改编自Vasya Novikov的answer以使其更加二进制，并使用
StringBuilder提高效率（在Java中将String对象连接起来通常效率低下） .输出：
michal.kreuzman很好，我将不得不说 . 当我发现它真的帮助了我时，我自己做了一个程序并在网上搜索代码时感到很懒 . 但我害怕看到它只适用于单个数字，就像你要使用多个数字一样，因为你使用的是空格而不是制表符，结构会被错放，程序将无法使用它 . 至于我后来的代码，我需要一些更大的输入（至少超过10个）这对我不起作用，并且在我没有找到任何东西后在网上搜索了很多，我自己做了一个程序 . 它现在有一些错误，现在我再次感觉懒得纠正它们但它打印得非常漂亮，节点可以承担任何大的 Value .
树不会像提到的问题那样，但它旋转270度:)
将此函数放在您自己指定的TreeNode中，并将该级别保持为初始值0 .
享受 . 以下是一些示例输出 .
唯一的问题是扩展分支我会尽快解决问题，但在此之前你也可以使用它 .
你的树每层需要两倍的距离：
您可以将树保存在一个数组数组中，每个深度都有一个数组：
如果树未满，则需要在该数组中包含空值：
然后，您可以遍历数组以打印树，在第一个元素之前打印空间，在元素之间打印空间，具体取决于深度并打印行，具体取决于是否填充了下一个图层的数组中的相应元素 . 如果您的值可以超过一个字符长，则需要在创建数组表示时找到最长值，并相应地乘以所有宽度和行数 .
我发现VasyaNovikov的答案对于打印大型通用树非常有用，并将其修改为二叉树
码：
样本输出：
Scala 语言的解决方案，类似于I wrote in java：
输出示例：
与java解决方案相比，它没有不必要的基本缩进，并且更好地连接
String-s（引擎盖下的StringBuilder） . 它仍然可以导致深度嵌套树的StackOverflow异常 . 改进的空间.--)这是一个打印出树的非常简单的解决方案 . 它不是那么漂亮，但它非常简单：
样本输出：
我知道你们都有很好的解决方案;我只想分享我的 - 也许这不是最好的方式，但它对我自己来说是完美的！
有了
python和pip，它真的很简单！繁荣！在Mac或Ubuntu上（我的是mac）
开放终端
$ pip install drawtree$python，进入python控制台;你可以用其他方式做到这一点from drawtree import draw_level_orderdraw_level_order('{2,1,3,0,7,9,1,2,#,1,0,#,#,8,8,#,#,#,#,7}')DONE！
来源跟踪：
在我看到这篇文章之前，我去谷歌“二叉树纯文本”
我找到了这个https://www.reddit.com/r/learnpython/comments/3naiq8/draw_binary_tree_in_plain_text/，指示我这个https://github.com/msbanik/drawtree
我需要在我的一个项目中打印一个二叉树，因为我准备了一个java类
TreePrinter，其中一个示例输出是：这是类
TreePrinter的代码以及类TextNode. 要打印任何树，您只需使用TextNode类创建等效树 .最后，这是一个用于打印给定样本的测试类：
您可以使用applet轻松地将其可视化 . 您需要打印以下项目 .
将节点打印为具有一些可见半径的圆
获取每个节点的坐标 .
可以将x坐标可视化为节点数在其顺序遍历中访问节点之前访问过 .
可以将y坐标可视化为特定节点的深度 .
打印父级和子级之间的行
这可以通过将节点的x和y坐标以及每个节点的父节点保持在单独的列表中来完成 .
对于除root之外的每个节点，通过获取子节点和父节点的x和y坐标，将每个节点与其父节点连接起来 .
https://github.com/murtraja/java-binary-tree-printer
仅适用于1到2位数的整数（我懒得把它变成通用的）
在控制台中打印：
简单代码：
这是一款功能多样的树形打印机 . 不是最好看，但它处理了很多情况 . 如果你能搞清楚，可以随意添加斜线 .
NodeInfo类
NodePosition类
最后，节点接口
C++:
Input :
balancer 树创建自：
Output:
Algorithm:
创建链接列表节点的ArrayList .
使用队列（广度优先搜索）进行级别顺序遍历 .
为了获取每个级别的所有节点，在从队列中取出节点之前，将队列的大小存储在变量中，比如将其称为levelNodes .
现在当levelNodes> 0时，取出节点并打印它们并将它们的子节点添加到队列中 .
在此循环之后放置一个换行符 .
Scala解决方案，改编自Vasya Novikov的答案，专门用于二叉树：
另见these answers .
特别是使用abego TreeLayout以默认设置生成下面显示的结果并不太难 .
如果您尝试使用该工具，请注意以下警告：它按照添加顺序打印子项 . 对于左右对比的BST，我发现这个库不合适而没有修改 .
此外，添加子项的方法只需要
parent和child节点作为参数 . （因此，要处理一堆节点，必须分别使用第一个节点来创建根节点 . ）我最终使用上面的this solution，修改它以接受类型
<Node>，以便能够访问Node的左和右（儿童） .这是另一种可视化树的方法：将节点保存为xml文件，然后让浏览器显示层次结构：
这是测试它的代码：
输出看起来像这样：
根据VasyaNovikov回答 . 改进了一些Java魔术：泛型和功能界面 .
初始调用示例：
会输出类似的东西