blocks|key|1005747|text|我已经创建了简单的二叉树打印机。您可以随心所欲地使用和修改它，但无论如何它都不是最优化的。我认为这里有很多地方可以改进;)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1005748|import+java.util.ArrayList;
import+java.util.Collections;
import+java.util.List;

public+class+BTreePrinterTest+{

++++private+static+Node<Integer>+test1()+{
++++++++Node<Integer>+root+=+new+Node<Integer>(2);
++++++++Node<Integer>+n11+=+new+Node<Integer>(7);
++++++++Node<Integer>+n12+=+new+Node<Integer>(5);
++++++++Node<Integer>+n21+=+new+Node<Integer>(2);
++++++++Node<Integer>+n22+=+new+Node<Integer>(6);
++++++++Node<Integer>+n23+=+new+Node<Integer>(3);
++++++++Node<Integer>+n24+=+new+Node<Integer>(6);
++++++++Node<Integer>+n31+=+new+Node<Integer>(5);
++++++++Node<Integer>+n32+=+new+Node<Integer>(8);
++++++++Node<Integer>+n33+=+new+Node<Integer>(4);
++++++++Node<Integer>+n34+=+new+Node<Integer>(5);
++++++++Node<Integer>+n35+=+new+Node<Integer>(8);
++++++++Node<Integer>+n36+=+new+Node<Integer>(4);
++++++++Node<Integer>+n37+=+new+Node<Integer>(5);
++++++++Node<Integer>+n38+=+new+Node<Integer>(8);

++++++++root.left+=+n11;
++++++++root.right+=+n12;

++++++++n11.left+=+n21;
++++++++n11.right+=+n22;
++++++++n12.left+=+n23;
++++++++n12.right+=+n24;

++++++++n21.left+=+n31;
++++++++n21.right+=+n32;
++++++++n22.left+=+n33;
++++++++n22.right+=+n34;
++++++++n23.left+=+n35;
++++++++n23.right+=+n36;
++++++++n24.left+=+n37;
++++++++n24.right+=+n38;

++++++++return+root;
++++}

++++private+static+Node<Integer>+test2()+{
++++++++Node<Integer>+root+=+new+Node<Integer>(2);
++++++++Node<Integer>+n11+=+new+Node<Integer>(7);
++++++++Node<Integer>+n12+=+new+Node<Integer>(5);
++++++++Node<Integer>+n21+=+new+Node<Integer>(2);
++++++++Node<Integer>+n22+=+new+Node<Integer>(6);
++++++++Node<Integer>+n23+=+new+Node<Integer>(9);
++++++++Node<Integer>+n31+=+new+Node<Integer>(5);
++++++++Node<Integer>+n32+=+new+Node<Integer>(8);
++++++++Node<Integer>+n33+=+new+Node<Integer>(4);

++++++++root.left+=+n11;
++++++++root.right+=+n12;

++++++++n11.left+=+n21;
++++++++n11.right+=+n22;

++++++++n12.right+=+n23;
++++++++n22.left+=+n31;
++++++++n22.right+=+n32;

++++++++n23.left+=+n33;

++++++++return+root;
++++}

++++public+static+void+main(String[]+args)+{

++++++++BTreePrinter.printNode(test1());
++++++++BTreePrinter.printNode(test2());

++++}
}

class+Node<T+extends+Comparable<?>>+{
++++Node<T>+left,+right;
++++T+data;

++++public+Node(T+data)+{
++++++++this.data+=+data;
++++}
}

class+BTreePrinter+{

++++public+static+<T+extends+Comparable<?>>+void+printNode(Node<T>+root)+{
++++++++int+maxLevel+=+BTreePrinter.maxLevel(root);

++++++++printNodeInternal(Collections.singletonList(root),+1,+maxLevel);
++++}

++++private+static+<T+extends+Comparable<?>>+void+printNodeInternal(List<Node<T>>+nodes,+int+level,+int+maxLevel)+{
++++++++if+(nodes.isEmpty()+%7C%7C+BTreePrinter.isAllElementsNull(nodes))
++++++++++++return;

++++++++int+floor+=+maxLevel+-+level;
++++++++int+endgeLines+=+(int)+Math.pow(2,+(Math.max(floor+-+1,+0)));
++++++++int+firstSpaces+=+(int)+Math.pow(2,+(floor))+-+1;
++++++++int+betweenSpaces+=+(int)+Math.pow(2,+(floor+%2B+1))+-+1;

++++++++BTreePrinter.printWhitespaces(firstSpaces);

++++++++List<Node<T>>+newNodes+=+new+ArrayList<Node<T>>();
++++++++for+(Node<T>+node+:+nodes)+{
++++++++++++if+(node+!=+null)+{
++++++++++++++++System.out.print(node.data);
++++++++++++++++newNodes.add(node.left);
++++++++++++++++newNodes.add(node.right);
++++++++++++}+else+{
++++++++++++++++newNodes.add(null);
++++++++++++++++newNodes.add(null);
++++++++++++++++System.out.print("+");
++++++++++++}

++++++++++++BTreePrinter.printWhitespaces(betweenSpaces);
++++++++}
++++++++System.out.println("");

++++++++for+(int+i+=+1;+i+<=+endgeLines;+i%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+nodes.size();+j%2B%2B)+{
++++++++++++++++BTreePrinter.printWhitespaces(firstSpaces+-+i);
++++++++++++++++if+(nodes.get(j)+==+null)+{
++++++++++++++++++++BTreePrinter.printWhitespaces(endgeLines+%2B+endgeLines+%2B+i+%2B+1);
++++++++++++++++++++continue;
++++++++++++++++}

++++++++++++++++if+(nodes.get(j).left+!=+null)
++++++++++++++++++++System.out.print("/");
++++++++++++++++else
++++++++++++++++++++BTreePrinter.printWhitespaces(1);

++++++++++++++++BTreePrinter.printWhitespaces(i+%2B+i+-+1);

++++++++++++++++if+(nodes.get(j).right+!=+null)
++++++++++++++++++++System.out.print("\\");
++++++++++++++++else
++++++++++++++++++++BTreePrinter.printWhitespaces(1);

++++++++++++++++BTreePrinter.printWhitespaces(endgeLines+%2B+endgeLines+-+i);
++++++++++++}

++++++++++++System.out.println("");
++++++++}

++++++++printNodeInternal(newNodes,+level+%2B+1,+maxLevel);
++++}

++++private+static+void+printWhitespaces(int+count)+{
++++++++for+(int+i+=+0;+i+<+count;+i%2B%2B)
++++++++++++System.out.print("+");
++++}

++++private+static+<T+extends+Comparable<?>>+int+maxLevel(Node<T>+node)+{
++++++++if+(node+==+null)
++++++++++++return+0;

++++++++return+Math.max(BTreePrinter.maxLevel(node.left),+BTreePrinter.maxLevel(node.right))+%2B+1;
++++}

++++private+static+<T>+boolean+isAllElementsNull(List<T>+list)+{
++++++++for+(Object+object+:+list)+{
++++++++++++if+(object+!=+null)
++++++++++++++++return+false;
++++++++}

++++++++return+true;
++++}

}|code-block|syntax|javascript|1005749|输出1：|1005750|+++++++++2+++++++++++++++
++++++++/+\+++++++
+++++++/+++\++++++
++++++/+++++\+++++
+++++/+++++++\++++
+++++7+++++++5+++++++
++++/+\+++++/+\+++
+++/+++\+++/+++\++
+++2+++6+++3+++6+++
++/+\+/+\+/+\+/+\+
++5+8+4+5+8+4+5+8+|1005751|输出2：|1005752|+++++++2+++++++++++++++
++++++/+\+++++++
+++++/+++\++++++
++++/+++++\+++++
+++/+++++++\++++
+++7+++++++5+++++++
++/+\+++++++\+++
+/+++\+++++++\++
+2+++6+++++++9+++
++++/+\+++++/+++
++++5+8+++++4+++|1005753|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I've created simple binary tree printer. You can use and modify it as you want, but it's not optimized anyway. I think that a lot of things can be improved here ;)

<pre><code>import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BTreePrinterTest {

 private static Node&lt;Integer&gt; test1() {
 Node&lt;Integer&gt; root = new Node&lt;Integer&gt;(2);
 Node&lt;Integer&gt; n11 = new Node&lt;Integer&gt;(7);
 Node&lt;Integer&gt; n12 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n21 = new Node&lt;Integer&gt;(2);
 Node&lt;Integer&gt; n22 = new Node&lt;Integer&gt;(6);
 Node&lt;Integer&gt; n23 = new Node&lt;Integer&gt;(3);
 Node&lt;Integer&gt; n24 = new Node&lt;Integer&gt;(6);
 Node&lt;Integer&gt; n31 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n32 = new Node&lt;Integer&gt;(8);
 Node&lt;Integer&gt; n33 = new Node&lt;Integer&gt;(4);
 Node&lt;Integer&gt; n34 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n35 = new Node&lt;Integer&gt;(8);
 Node&lt;Integer&gt; n36 = new Node&lt;Integer&gt;(4);
 Node&lt;Integer&gt; n37 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n38 = new Node&lt;Integer&gt;(8);

 root.left = n11;
 root.right = n12;

 n11.left = n21;
 n11.right = n22;
 n12.left = n23;
 n12.right = n24;

 n21.left = n31;
 n21.right = n32;
 n22.left = n33;
 n22.right = n34;
 n23.left = n35;
 n23.right = n36;
 n24.left = n37;
 n24.right = n38;

 return root;
 }

 private static Node&lt;Integer&gt; test2() {
 Node&lt;Integer&gt; root = new Node&lt;Integer&gt;(2);
 Node&lt;Integer&gt; n11 = new Node&lt;Integer&gt;(7);
 Node&lt;Integer&gt; n12 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n21 = new Node&lt;Integer&gt;(2);
 Node&lt;Integer&gt; n22 = new Node&lt;Integer&gt;(6);
 Node&lt;Integer&gt; n23 = new Node&lt;Integer&gt;(9);
 Node&lt;Integer&gt; n31 = new Node&lt;Integer&gt;(5);
 Node&lt;Integer&gt; n32 = new Node&lt;Integer&gt;(8);
 Node&lt;Integer&gt; n33 = new Node&lt;Integer&gt;(4);

 root.left = n11;
 root.right = n12;

 n11.left = n21;
 n11.right = n22;

 n12.right = n23;
 n22.left = n31;
 n22.right = n32;

 n23.left = n33;

 return root;
 }

 public static void main(String[] args) {

 BTreePrinter.printNode(test1());
 BTreePrinter.printNode(test2());

 }
}

class Node&lt;T extends Comparable&lt;?&gt;&gt; {
 Node&lt;T&gt; left, right;
 T data;

 public Node(T data) {
 this.data = data;
 }
}

class BTreePrinter {

 public static &lt;T extends Comparable&lt;?&gt;&gt; void printNode(Node&lt;T&gt; root) {
 int maxLevel = BTreePrinter.maxLevel(root);

 printNodeInternal(Collections.singletonList(root), 1, maxLevel);
 }

 private static &lt;T extends Comparable&lt;?&gt;&gt; void printNodeInternal(List&lt;Node&lt;T&gt;&gt; nodes, int level, int maxLevel) {
 if (nodes.isEmpty() || BTreePrinter.isAllElementsNull(nodes))
 return;

 int floor = maxLevel - level;
 int endgeLines = (int) Math.pow(2, (Math.max(floor - 1, 0)));
 int firstSpaces = (int) Math.pow(2, (floor)) - 1;
 int betweenSpaces = (int) Math.pow(2, (floor + 1)) - 1;

 BTreePrinter.printWhitespaces(firstSpaces);

 List&lt;Node&lt;T&gt;&gt; newNodes = new ArrayList&lt;Node&lt;T&gt;&gt;();
 for (Node&lt;T&gt; node : nodes) {
 if (node != null) {
 System.out.print(node.data);
 newNodes.add(node.left);
 newNodes.add(node.right);
 } else {
 newNodes.add(null);
 newNodes.add(null);
 System.out.print(" ");
 }

 BTreePrinter.printWhitespaces(betweenSpaces);
 }
 System.out.println("");

 for (int i = 1; i &lt;= endgeLines; i++) {
 for (int j = 0; j &lt; nodes.size(); j++) {
 BTreePrinter.printWhitespaces(firstSpaces - i);
 if (nodes.get(j) == null) {
 BTreePrinter.printWhitespaces(endgeLines + endgeLines + i + 1);
 continue;
 }

 if (nodes.get(j).left != null)
 System.out.print("/");
 else
 BTreePrinter.printWhitespaces(1);

 BTreePrinter.printWhitespaces(i + i - 1);

 if (nodes.get(j).right != null)
 System.out.print("\\");
 else
 BTreePrinter.printWhitespaces(1);

 BTreePrinter.printWhitespaces(endgeLines + endgeLines - i);
 }

 System.out.println("");
 }

 printNodeInternal(newNodes, level + 1, maxLevel);
 }

 private static void printWhitespaces(int count) {
 for (int i = 0; i &lt; count; i++)
 System.out.print(" ");
 }

 private static &lt;T extends Comparable&lt;?&gt;&gt; int maxLevel(Node&lt;T&gt; node) {
 if (node == null)
 return 0;

 return Math.max(BTreePrinter.maxLevel(node.left), BTreePrinter.maxLevel(node.right)) + 1;
 }

 private static &lt;T&gt; boolean isAllElementsNull(List&lt;T&gt; list) {
 for (Object object : list) {
 if (object != null)
 return false;
 }

 return true;
 }

}
</code></pre>

Output 1 :

<pre><code> 2 
 / \ 
 / \ 
 / \ 
 / \ 
 7 5 
 / \ / \ 
 / \ / \ 
 2 6 3 6 
 / \ / \ / \ / \ 
 5 8 4 5 8 4 5 8 
</code></pre>

Output 2 :

<pre><code> 2 
 / \ 
 / \ 
 / \ 
 / \ 
 7 5 
 / \ \ 
 / \ \ 
 2 6 9 
 / \ / 
 5 8 4 
</code></pre>

blocks|key|791768|text|逐行打印一棵大树。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|791769|输出示例：|791770|z
├── c
│   ├── a
│   └── b
├── d
├── e
│   └── asdf
└── f|code-block|syntax|javascript|791771|代码：|791772|public+class+TreeNode+{

++++final+String+name;
++++final+List<TreeNode>+children;

++++public+TreeNode(String+name,+List<TreeNode>+children)+{
++++++++this.name+=+name;
++++++++this.children+=+children;
++++}

++++public+String+toString()+{
++++++++StringBuilder+buffer+=+new+StringBuilder(50);
++++++++print(buffer,+"",+"");
++++++++return+buffer.toString();
++++}

++++private+void+print(StringBuilder+buffer,+String+prefix,+String+childrenPrefix)+{
++++++++buffer.append(prefix);
++++++++buffer.append(name);
++++++++buffer.append('\n');
++++++++for+(Iterator<TreeNode>+it+=+children.iterator();+it.hasNext();)+{
++++++++++++TreeNode+next+=+it.next();
++++++++++++if+(it.hasNext())+{
++++++++++++++++next.print(buffer,+childrenPrefix+%2B+"├──+",+childrenPrefix+%2B+"│+++");
++++++++++++}+else+{
++++++++++++++++next.print(buffer,+childrenPrefix+%2B+"└──+",+childrenPrefix+%2B+"++++");
++++++++++++}
++++++++}
++++}
}|791773|附注:这个答案并不完全集中在“二进制”树上--相反，它打印所有类型的树。解决方案的灵感来自linux中的"tree“命令。|791774|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Print a [large] tree by lines.

output example:

<pre><code>z
├── c
│   ├── a
│   └── b
├── d
├── e
│   └── asdf
└── f
</code></pre>

code:

<pre><code>public class TreeNode {

 final String name;
 final List&lt;TreeNode&gt; children;

 public TreeNode(String name, List&lt;TreeNode&gt; children) {
 this.name = name;
 this.children = children;
 }

 public String toString() {
 StringBuilder buffer = new StringBuilder(50);
 print(buffer, "", "");
 return buffer.toString();
 }

 private void print(StringBuilder buffer, String prefix, String childrenPrefix) {
 buffer.append(prefix);
 buffer.append(name);
 buffer.append('\n');
 for (Iterator&lt;TreeNode&gt; it = children.iterator(); it.hasNext();) {
 TreeNode next = it.next();
 if (it.hasNext()) {
 next.print(buffer, childrenPrefix + "├── ", childrenPrefix + "│ ");
 } else {
 next.print(buffer, childrenPrefix + "└── ", childrenPrefix + " ");
 }
 }
 }
}
</code></pre>

P.S. This answer doesn't exactly focus on "binary" trees -- instead, it prints all kinds of trees. Solution is inspired by the "tree" command in linux.

blocks|key|791792|text|我不得不说，michal.kreuzman是个不错的选择。这很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|791793|然而，上述方法仅适用于单个数字:如果您要使用多个数字，结构将会错位，因为您使用的是空格而不是制表符。|791794|至于我后来的代码，我需要比2位更多的数字，所以我自己写了一个程序。|791795|它现在有一些bug，现在我觉得懒得去纠正它们，但它打印得非常漂亮，节点可以接受更多的数字。|791796|树不会像问题提到的那样旋转，但它被旋转了270度:)|791797|public+static+void+printBinaryTree(TreeNode+root,+int+level){
++++if(root==null)
+++++++++return;
++++printBinaryTree(root.right,+level%2B1);
++++if(level!=0){
++++++++for(int+i=0;i<level-1;i%2B%2B)
++++++++++++System.out.print("%7C\t");
++++++++System.out.println("%7C-------"%2Broot.val);
++++}
++++else
++++++++System.out.println(root.val);
++++printBinaryTree(root.left,+level%2B1);
}++++|code-block|syntax|javascript|791798|将此函数与您自己指定的TreeNode放在一起，并保持初始级别为0，尽情享受吧！|791799|以下是一些示例输出：|791800|%7C+++++++%7C+++++++%7C-------11
%7C+++++++%7C-------10
%7C+++++++%7C+++++++%7C-------9
%7C-------8
%7C+++++++%7C+++++++%7C-------7
%7C+++++++%7C-------6
%7C+++++++%7C+++++++%7C-------5
4
%7C+++++++%7C-------3
%7C-------2
%7C+++++++%7C-------1


%7C+++++++%7C+++++++%7C+++++++%7C-------10
%7C+++++++%7C+++++++%7C-------9
%7C+++++++%7C-------8
%7C+++++++%7C+++++++%7C-------7
%7C-------6
%7C+++++++%7C-------5
4
%7C+++++++%7C-------3
%7C-------2
%7C+++++++%7C-------1|791801|唯一的问题是扩展分支；我会尽快解决这个问题，但在此之前，您也可以使用它。|791802|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

michal.kreuzman nice one I will have to say. It was useful.
However, the above works only for single digits: if you are going to use more than one digit, the structure is going to get misplaced since you are using spaces and not tabs.
As for my later codes I needed more digits than only 2, so I made a program myself.
It has some bugs now, again right now I am feeling lazy to correct them but it prints very beautifully and the nodes can take a larger number of digits.
The tree is not going to be as the question mentions but it is 270 degrees rotated :)
<pre><code>public static void printBinaryTree(TreeNode root, int level){
 if(root==null)
 return;
 printBinaryTree(root.right, level+1);
 if(level!=0){
 for(int i=0;i&lt;level-1;i++)
 System.out.print(&quot;|\t&quot;);
 System.out.println(&quot;|-------&quot;+root.val);
 }
 else
 System.out.println(root.val);
 printBinaryTree(root.left, level+1);
} 
</code></pre>
Place this function with your own specified TreeNode and keep the level initially 0, and enjoy!
Here are some of the sample outputs:
<pre><code>| | |-------11
| |-------10
| | |-------9
|-------8
| | |-------7
| |-------6
| | |-------5
4
| |-------3
|-------2
| |-------1


| | | |-------10
| | |-------9
| |-------8
| | |-------7
|-------6
| |-------5
4
| |-------3
|-------2
| |-------1
</code></pre>
Only problem is with the extending branches; I will try to solve the problem as soon as possible but till then you can use it too.

blocks|key|1005812|text|public+static+class+Node<T+extends+Comparable<T>>+{
++++T+value;
++++Node<T>+left,+right;

++++public+void+insertToTree(T+v)+{
++++++++if+(value+==+null)+{
++++++++++++value+=+v;
++++++++++++return;
++++++++}
++++++++if+(v.compareTo(value)+<+0)+{
++++++++++++if+(left+==+null)+{
++++++++++++++++left+=+new+Node<T>();
++++++++++++}
++++++++++++left.insertToTree(v);
++++++++}+else+{
++++++++++++if+(right+==+null)+{
++++++++++++++++right+=+new+Node<T>();
++++++++++++}
++++++++++++right.insertToTree(v);
++++++++}
++++}

++++public+void+printTree(OutputStreamWriter+out)+throws+IOException+{
++++++++if+(right+!=+null)+{
++++++++++++right.printTree(out,+true,+"");
++++++++}
++++++++printNodeValue(out);
++++++++if+(left+!=+null)+{
++++++++++++left.printTree(out,+false,+"");
++++++++}
++++}
++++private+void+printNodeValue(OutputStreamWriter+out)+throws+IOException+{
++++++++if+(value+==+null)+{
++++++++++++out.write("<null>");
++++++++}+else+{
++++++++++++out.write(value.toString());
++++++++}
++++++++out.write('\n');
++++}
++++//+use+string+and+not+stringbuffer+on+purpose+as+we+need+to+change+the+indent+at+each+recursion
++++private+void+printTree(OutputStreamWriter+out,+boolean+isRight,+String+indent)+throws+IOException+{
++++++++if+(right+!=+null)+{
++++++++++++right.printTree(out,+true,+indent+%2B+(isRight+?+"++++++++"+:+"+%7C++++++"));
++++++++}
++++++++out.write(indent);
++++++++if+(isRight)+{
++++++++++++out.write("+/");
++++++++}+else+{
++++++++++++out.write("+\\");
++++++++}
++++++++out.write("-----+");
++++++++printNodeValue(out);
++++++++if+(left+!=+null)+{
++++++++++++left.printTree(out,+false,+indent+%2B+(isRight+?+"+%7C++++++"+:+"++++++++"));
++++++++}
++++}

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1005813|将打印：|unstyled|1005814|+++++++++++++++++/-----+20
+++++++++++++++++%7C+++++++\-----+15
+++++++++/-----+14
+++++++++%7C+++++++\-----+13
+/-----+12
+%7C+++++++%7C+++++++/-----+11
+%7C+++++++\-----+10
+%7C+++++++++++++++\-----+9
8
+%7C+++++++++++++++/-----+7
+%7C+++++++/-----+6
+%7C+++++++%7C+++++++\-----+5
+\-----+4
+++++++++%7C+++++++/-----+3
+++++++++\-----+2
+++++++++++++++++\-----+1|1005815|对于输入|1005816|8+4+12+2+6+10+14+1+3+5+7+9+11+13+20+15|1005817|这是@anurag答案的一个变体--看到额外的%7Cs让我很烦|1005818|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>public static class Node&lt;T extends Comparable&lt;T&gt;&gt; {
 T value;
 Node&lt;T&gt; left, right;

 public void insertToTree(T v) {
 if (value == null) {
 value = v;
 return;
 }
 if (v.compareTo(value) &lt; 0) {
 if (left == null) {
 left = new Node&lt;T&gt;();
 }
 left.insertToTree(v);
 } else {
 if (right == null) {
 right = new Node&lt;T&gt;();
 }
 right.insertToTree(v);
 }
 }

 public void printTree(OutputStreamWriter out) throws IOException {
 if (right != null) {
 right.printTree(out, true, "");
 }
 printNodeValue(out);
 if (left != null) {
 left.printTree(out, false, "");
 }
 }
 private void printNodeValue(OutputStreamWriter out) throws IOException {
 if (value == null) {
 out.write("&lt;null&gt;");
 } else {
 out.write(value.toString());
 }
 out.write('\n');
 }
 // use string and not stringbuffer on purpose as we need to change the indent at each recursion
 private void printTree(OutputStreamWriter out, boolean isRight, String indent) throws IOException {
 if (right != null) {
 right.printTree(out, true, indent + (isRight ? " " : " | "));
 }
 out.write(indent);
 if (isRight) {
 out.write(" /");
 } else {
 out.write(" \\");
 }
 out.write("----- ");
 printNodeValue(out);
 if (left != null) {
 left.printTree(out, false, indent + (isRight ? " | " : " "));
 }
 }

}
</code></pre>

will print:

<pre><code> /----- 20
 | \----- 15
 /----- 14
 | \----- 13
 /----- 12
 | | /----- 11
 | \----- 10
 | \----- 9
8
 | /----- 7
 | /----- 6
 | | \----- 5
 \----- 4
 | /----- 3
 \----- 2
 \----- 1
</code></pre>

for the input

8
4
12
2
6
10
14
1
3
5
7
9
11
13
20
15

this is a variant from @anurag's answer - it was bugging me to see the extra |s

blocks|key|1005831|text|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+%2B+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+++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1005832|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public void printPreety() {
 List&lt;TreeNode&gt; list = new ArrayList&lt;TreeNode&gt;();
 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&lt;TreeNode&gt; levelNodes, int level) {

 List&lt;TreeNode&gt; nodes = new ArrayList&lt;TreeNode&gt;();

 //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&gt;1){
 nodes.add(treeNode == null? null:treeNode.left);
 nodes.add(treeNode == null? null:treeNode.right);
 }
 }
 System.out.println();

 if(level&gt;1){ 
 printTree(nodes, level-1);
 }
}

private void printIndentForLevel(int level){
 for (int i = (int) (Math.pow(2,level-1)); i &gt;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 &gt;0; i--) {
 System.out.print(" ");
 }
}


Prints Tree in following format:
 4 
 3 7 
 1 5 8 
 2 10 
 9 
</code></pre>

blocks|key|1005868|text|我为此做了一个改进的算法，它可以很好地处理不同大小的节点。它使用行从上到下打印。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1005869|package+alg;

import+java.util.ArrayList;
import+java.util.List;


/**
+*+Binary+tree+printer
+*+
+*+@author+MightyPork
+*/
public+class+TreePrinter
{
++++/**+Node+that+can+be+printed+*/
++++public+interface+PrintableNode
++++{
++++++++/**+Get+left+child+*/
++++++++PrintableNode+getLeft();


++++++++/**+Get+right+child+*/
++++++++PrintableNode+getRight();


++++++++/**+Get+text+to+be+printed+*/
++++++++String+getText();
++++}


++++/**
+++++*+Print+a+tree
+++++*+
+++++*+@param+root
+++++*++++++++++++tree+root+node
+++++*/
++++public+static+void+print(PrintableNode+root)
++++{
++++++++List<List<String>>+lines+=+new+ArrayList<List<String>>();

++++++++List<PrintableNode>+level+=+new+ArrayList<PrintableNode>();
++++++++List<PrintableNode>+next+=+new+ArrayList<PrintableNode>();

++++++++level.add(root);
++++++++int+nn+=+1;

++++++++int+widest+=+0;

++++++++while+(nn+!=+0)+{
++++++++++++List<String>+line+=+new+ArrayList<String>();

++++++++++++nn+=+0;

++++++++++++for+(PrintableNode+n+:+level)+{
++++++++++++++++if+(n+==+null)+{
++++++++++++++++++++line.add(null);

++++++++++++++++++++next.add(null);
++++++++++++++++++++next.add(null);
++++++++++++++++}+else+{
++++++++++++++++++++String+aa+=+n.getText();
++++++++++++++++++++line.add(aa);
++++++++++++++++++++if+(aa.length()+>+widest)+widest+=+aa.length();

++++++++++++++++++++next.add(n.getLeft());
++++++++++++++++++++next.add(n.getRight());

++++++++++++++++++++if+(n.getLeft()+!=+null)+nn%2B%2B;
++++++++++++++++++++if+(n.getRight()+!=+null)+nn%2B%2B;
++++++++++++++++}
++++++++++++}

++++++++++++if+(widest+%25+2+==+1)+widest%2B%2B;

++++++++++++lines.add(line);

++++++++++++List<PrintableNode>+tmp+=+level;
++++++++++++level+=+next;
++++++++++++next+=+tmp;
++++++++++++next.clear();
++++++++}

++++++++int+perpiece+=+lines.get(lines.size()+-+1).size()+*+(widest+%2B+4);
++++++++for+(int+i+=+0;+i+<+lines.size();+i%2B%2B)+{
++++++++++++List<String>+line+=+lines.get(i);
++++++++++++int+hpw+=+(int)+Math.floor(perpiece+/+2f)+-+1;

++++++++++++if+(i+>+0)+{
++++++++++++++++for+(int+j+=+0;+j+<+line.size();+j%2B%2B)+{

++++++++++++++++++++//+split+node
++++++++++++++++++++char+c+=+'+';
++++++++++++++++++++if+(j+%25+2+==+1)+{
++++++++++++++++++++++++if+(line.get(j+-+1)+!=+null)+{
++++++++++++++++++++++++++++c+=+(line.get(j)+!=+null)+?+'┴'+:+'┘';
++++++++++++++++++++++++}+else+{
++++++++++++++++++++++++++++if+(j+<+line.size()+&&+line.get(j)+!=+null)+c+=+'└';
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++System.out.print(c);

++++++++++++++++++++//+lines+and+spaces
++++++++++++++++++++if+(line.get(j)+==+null)+{
++++++++++++++++++++++++for+(int+k+=+0;+k+<+perpiece+-+1;+k%2B%2B)+{
++++++++++++++++++++++++++++System.out.print("+");
++++++++++++++++++++++++}
++++++++++++++++++++}+else+{

++++++++++++++++++++++++for+(int+k+=+0;+k+<+hpw;+k%2B%2B)+{
++++++++++++++++++++++++++++System.out.print(j+%25+2+==+0+?+"+"+:+"─");
++++++++++++++++++++++++}
++++++++++++++++++++++++System.out.print(j+%25+2+==+0+?+"┌"+:+"┐");
++++++++++++++++++++++++for+(int+k+=+0;+k+<+hpw;+k%2B%2B)+{
++++++++++++++++++++++++++++System.out.print(j+%25+2+==+0+?+"─"+:+"+");
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++System.out.println();
++++++++++++}

++++++++++++//+print+line+of+numbers
++++++++++++for+(int+j+=+0;+j+<+line.size();+j%2B%2B)+{

++++++++++++++++String+f+=+line.get(j);
++++++++++++++++if+(f+==+null)+f+=+"";
++++++++++++++++int+gap1+=+(int)+Math.ceil(perpiece+/+2f+-+f.length()+/+2f);
++++++++++++++++int+gap2+=+(int)+Math.floor(perpiece+/+2f+-+f.length()+/+2f);

++++++++++++++++//+a+number
++++++++++++++++for+(int+k+=+0;+k+<+gap1;+k%2B%2B)+{
++++++++++++++++++++System.out.print("+");
++++++++++++++++}
++++++++++++++++System.out.print(f);
++++++++++++++++for+(int+k+=+0;+k+<+gap2;+k%2B%2B)+{
++++++++++++++++++++System.out.print("+");
++++++++++++++++}
++++++++++++}
++++++++++++System.out.println();

++++++++++++perpiece+/=+2;
++++++++}
++++}
}|code-block|syntax|javascript|1005870|要将其用于树，请让您的Node类实现PrintableNode。|offset|length|style|CODE|1005871|输出示例：|1005872|+++++++++++++++++++++++++++++++++++++++++2952:0+++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++┌───────────────────────┴───────────────────────┐+++++++++++++++++++++++
+++++++++++++++++1249:-1+++++++++++++++++++++++++++++++++++++++++5866:0+++++++++++++++++++++
++++++++┌───────────┴───────────┐+++++++++++++++++++++++┌───────────┴───────────┐+++++++++++
+++++491:-1++++++++++++++++++1572:0++++++++++++++++++4786:1++++++++++++++++++6190:0+++++++++
++┌─────┘+++++++++++++++++++++++++++++++++++++++++++++++└─────┐+++++++++++┌─────┴─────┐+++++
339:0++++++++++++++++++++++++++++++++++++++++++++++++++++++5717:0++++++6061:0++++++6271:0+++|1005873|entityMap^0|0|0|B|4|I|D|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

I've made an improved algorithm for this, which handles nicely nodes with different size. It prints top-down using lines.

<pre><code>package alg;

import java.util.ArrayList;
import java.util.List;


/**
 * Binary tree printer
 * 
 * @author MightyPork
 */
public class TreePrinter
{
 /** Node that can be printed */
 public interface PrintableNode
 {
 /** Get left child */
 PrintableNode getLeft();


 /** Get right child */
 PrintableNode getRight();


 /** Get text to be printed */
 String getText();
 }


 /**
 * Print a tree
 * 
 * @param root
 * tree root node
 */
 public static void print(PrintableNode root)
 {
 List&lt;List&lt;String&gt;&gt; lines = new ArrayList&lt;List&lt;String&gt;&gt;();

 List&lt;PrintableNode&gt; level = new ArrayList&lt;PrintableNode&gt;();
 List&lt;PrintableNode&gt; next = new ArrayList&lt;PrintableNode&gt;();

 level.add(root);
 int nn = 1;

 int widest = 0;

 while (nn != 0) {
 List&lt;String&gt; line = new ArrayList&lt;String&gt;();

 nn = 0;

 for (PrintableNode n : level) {
 if (n == null) {
 line.add(null);

 next.add(null);
 next.add(null);
 } else {
 String aa = n.getText();
 line.add(aa);
 if (aa.length() &gt; widest) widest = aa.length();

 next.add(n.getLeft());
 next.add(n.getRight());

 if (n.getLeft() != null) nn++;
 if (n.getRight() != null) nn++;
 }
 }

 if (widest % 2 == 1) widest++;

 lines.add(line);

 List&lt;PrintableNode&gt; tmp = level;
 level = next;
 next = tmp;
 next.clear();
 }

 int perpiece = lines.get(lines.size() - 1).size() * (widest + 4);
 for (int i = 0; i &lt; lines.size(); i++) {
 List&lt;String&gt; line = lines.get(i);
 int hpw = (int) Math.floor(perpiece / 2f) - 1;

 if (i &gt; 0) {
 for (int j = 0; j &lt; line.size(); j++) {

 // split node
 char c = ' ';
 if (j % 2 == 1) {
 if (line.get(j - 1) != null) {
 c = (line.get(j) != null) ? '┴' : '┘';
 } else {
 if (j &lt; line.size() &amp;&amp; line.get(j) != null) c = '└';
 }
 }
 System.out.print(c);

 // lines and spaces
 if (line.get(j) == null) {
 for (int k = 0; k &lt; perpiece - 1; k++) {
 System.out.print(" ");
 }
 } else {

 for (int k = 0; k &lt; hpw; k++) {
 System.out.print(j % 2 == 0 ? " " : "─");
 }
 System.out.print(j % 2 == 0 ? "┌" : "┐");
 for (int k = 0; k &lt; hpw; k++) {
 System.out.print(j % 2 == 0 ? "─" : " ");
 }
 }
 }
 System.out.println();
 }

 // print line of numbers
 for (int j = 0; j &lt; line.size(); j++) {

 String f = line.get(j);
 if (f == null) f = "";
 int gap1 = (int) Math.ceil(perpiece / 2f - f.length() / 2f);
 int gap2 = (int) Math.floor(perpiece / 2f - f.length() / 2f);

 // a number
 for (int k = 0; k &lt; gap1; k++) {
 System.out.print(" ");
 }
 System.out.print(f);
 for (int k = 0; k &lt; gap2; k++) {
 System.out.print(" ");
 }
 }
 System.out.println();

 perpiece /= 2;
 }
 }
}
</code></pre>

To use this for your Tree, let your <code>Node</code> class implement <code>PrintableNode</code>.

Example output:

<pre><code> 2952:0 
 ┌───────────────────────┴───────────────────────┐ 
 1249:-1 5866:0 
 ┌───────────┴───────────┐ ┌───────────┴───────────┐ 
 491:-1 1572:0 4786:1 6190:0 
 ┌─────┘ └─────┐ ┌─────┴─────┐ 
339:0 5717:0 6061:0 6271:0 
</code></pre>

blocks|key|791962|text|private+StringBuilder+prettyPrint(Node+root,+int+currentHeight,+int+totalHeight)+{
++++++++StringBuilder+sb+=+new+StringBuilder();
++++++++int+spaces+=+getSpaceCount(totalHeight-currentHeight+%2B+1);
++++++++if(root+==+null)+{
++++++++++++//create+a+'spatial'+block+and+return+it
++++++++++++String+row+=+String.format("%25"%2B(2*spaces%2B1)%2B"s%25n",+"");
++++++++++++//now+repeat+this+row+space%2B1+times
++++++++++++String+block+=+new+String(new+char[spaces%2B1]).replace("\0",+row);
++++++++++++return+new+StringBuilder(block);
++++++++}
++++++++if(currentHeight==totalHeight)+return+new+StringBuilder(root.data%2B"");
++++++++int+slashes+=+getSlashCount(totalHeight-currentHeight+%2B1);
++++++++sb.append(String.format("%25"%2B(spaces%2B1)%2B"s%25"%2Bspaces%2B"s",+root.data%2B"",+""));
++++++++sb.append("\n");
++++++++//now+print+/+and+\
++++++++//+but+make+sure+that+left+and+right+exists
++++++++char+leftSlash+=+root.left+==+null?+'+':'/';
++++++++char+rightSlash+=+root.right==null?+'+':'\\';
++++++++int+spaceInBetween+=+1;
++++++++for(int+i=0,+space+=+spaces-1;+i<slashes;+i%2B%2B,+space+--,+spaceInBetween%2B=2)+{
++++++++++++for(int+j=0;+j<space;+j%2B%2B)+sb.append("+");
++++++++++++sb.append(leftSlash);
++++++++++++for(int+j=0;+j<spaceInBetween;+j%2B%2B)+sb.append("+");
++++++++++++sb.append(rightSlash%2B"");
++++++++++++for(int+j=0;+j<space;+j%2B%2B)+sb.append("+");
++++++++++++sb.append("\n");
++++++++}
++++++++//sb.append("\n");

++++++++//now+get+string+representations+of+left+and+right+subtrees
++++++++StringBuilder+leftTree+=+prettyPrint(root.left,+currentHeight%2B1,+totalHeight);
++++++++StringBuilder+rightTree+=+prettyPrint(root.right,+currentHeight%2B1,+totalHeight);
++++++++//+now+line+by+line+print+the+trees+side+by+side
++++++++Scanner+leftScanner+=+new+Scanner(leftTree.toString());
++++++++Scanner+rightScanner+=+new+Scanner(rightTree.toString());
//++++++spaceInBetween%2B=1;
++++++++while(leftScanner.hasNextLine())+{
++++++++++++if(currentHeight==totalHeight-1)+{
++++++++++++++++sb.append(String.format("%25-2s+%252s",+leftScanner.nextLine(),+rightScanner.nextLine()));
++++++++++++++++sb.append("\n");
++++++++++++++++spaceInBetween-=2;++++++++++++++
++++++++++++}
++++++++++++else+{
++++++++++++++++sb.append(leftScanner.nextLine());
++++++++++++++++sb.append("+");
++++++++++++++++sb.append(rightScanner.nextLine()%2B"\n");
++++++++++++}
++++++++}

++++++++return+sb;

++++}
private+int+getSpaceCount(int+height)+{
++++++++return+(int)+(3*Math.pow(2,+height-2)-1);
++++}
private+int+getSlashCount(int+height)+{
++++++++if(height+<=+3)+return+height+-1;
++++++++return+(int)+(3*Math.pow(2,+height-3)-1);
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|791963|https://github.com/murtraja/java-binary-tree-printer|unstyled|offset|length|791964|只适用于1到2位的整数(我懒得让它泛型)|791965|​|791966|📷|atomic|791967|791968|791969|entityMap|0|LINK|mutability|MUTABLE|url|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/47b0b2e26a6c6d75d1833d9537a9a556.png|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/adddd71564cda8ccc2a060fb965d502c.png^0|0|0|1G|0|0|0|0|0|1|1|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|17|8|@]|9|@$G|18|H|19|1|1A]]|A|$]]|$1|I|3|J|5|F|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1D|8|@]|9|@$G|1E|H|1F|1|1G]]|A|$]]|$1|P|3|N|5|O|7|1H|8|@]|9|@$G|1I|H|1J|1|1K]]|A|$]]|$1|Q|3|L|5|F|7|1L|8|@]|9|@]|A|$]]|$1|R|3|-4|5|F|7|1M|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|E]]|Y|$5|Z|V|10|A|$11|12|13|-4]]|14|$5|Z|V|10|A|$11|15|13|-4]]]]

<pre><code>private StringBuilder prettyPrint(Node root, int currentHeight, int totalHeight) {
 StringBuilder sb = new StringBuilder();
 int spaces = getSpaceCount(totalHeight-currentHeight + 1);
 if(root == null) {
 //create a 'spatial' block and return it
 String row = String.format("%"+(2*spaces+1)+"s%n", "");
 //now repeat this row space+1 times
 String block = new String(new char[spaces+1]).replace("\0", row);
 return new StringBuilder(block);
 }
 if(currentHeight==totalHeight) return new StringBuilder(root.data+"");
 int slashes = getSlashCount(totalHeight-currentHeight +1);
 sb.append(String.format("%"+(spaces+1)+"s%"+spaces+"s", root.data+"", ""));
 sb.append("\n");
 //now print / and \
 // but make sure that left and right exists
 char leftSlash = root.left == null? ' ':'/';
 char rightSlash = root.right==null? ' ':'\\';
 int spaceInBetween = 1;
 for(int i=0, space = spaces-1; i&lt;slashes; i++, space --, spaceInBetween+=2) {
 for(int j=0; j&lt;space; j++) sb.append(" ");
 sb.append(leftSlash);
 for(int j=0; j&lt;spaceInBetween; j++) sb.append(" ");
 sb.append(rightSlash+"");
 for(int j=0; j&lt;space; j++) sb.append(" ");
 sb.append("\n");
 }
 //sb.append("\n");

 //now get string representations of left and right subtrees
 StringBuilder leftTree = prettyPrint(root.left, currentHeight+1, totalHeight);
 StringBuilder rightTree = prettyPrint(root.right, currentHeight+1, totalHeight);
 // now line by line print the trees side by side
 Scanner leftScanner = new Scanner(leftTree.toString());
 Scanner rightScanner = new Scanner(rightTree.toString());
// spaceInBetween+=1;
 while(leftScanner.hasNextLine()) {
 if(currentHeight==totalHeight-1) {
 sb.append(String.format("%-2s %2s", leftScanner.nextLine(), rightScanner.nextLine()));
 sb.append("\n");
 spaceInBetween-=2; 
 }
 else {
 sb.append(leftScanner.nextLine());
 sb.append(" ");
 sb.append(rightScanner.nextLine()+"\n");
 }
 }

 return sb;

 }
private int getSpaceCount(int height) {
 return (int) (3*Math.pow(2, height-2)-1);
 }
private int getSlashCount(int height) {
 if(height &lt;= 3) return height -1;
 return (int) (3*Math.pow(2, height-3)-1);
 }
</code></pre>

<a href="https://github.com/murtraja/java-binary-tree-printer" rel="nofollow noreferrer">https://github.com/murtraja/java-binary-tree-printer</a>

only works for 1 to 2 digit integers (i was lazy to make it generic)

<a href="https://i.stack.imgur.com/PbJzM.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/PbJzM.png" alt="skewed"></a>
<a href="https://i.stack.imgur.com/WP2uj.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/WP2uj.png" alt="full"></a>

blocks|key|1005970|text|在控制台中打印：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1005971|++++++++++++++++++++++++++++++++++++++++++++++++500
+++++++++++++++++++++++700+++++++++++++++++++++++++++++++++++++++++++++300+++
++++200+++++++++++++++++++++++++++++++++++400++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++|code-block|syntax|javascript|1005972|简单的代码：|1005973|public+int+getHeight()
++++{
++++++++if(rootNode+==+null)+return+-1;
++++++++return+getHeight(rootNode);
++++}

++++private+int+getHeight(Node+node)
++++{
++++++++if(node+==+null)+return+-1;

++++++++return+Math.max(getHeight(node.left),+getHeight(node.right))+%2B+1;
++++}

++++public+void+printBinaryTree(Node+rootNode)
++++{
++++++++Queue<Node>+rootsQueue+=+new+LinkedList<Node>();
++++++++Queue<Node>+levelQueue+=+new+LinkedList<Node>();
++++++++levelQueue.add(rootNode);
++++++++int+treeHeight+=+getHeight();
++++++++int+firstNodeGap;
++++++++int+internalNodeGap;
++++++++int+copyinternalNodeGap;
++++++++while(true)
++++++++{
++++++++++++System.out.println("");
++++++++++++internalNodeGap+=+(int)(Math.pow(2,+treeHeight+%2B+1)+-1);++
++++++++++++copyinternalNodeGap+=+internalNodeGap;
++++++++++++firstNodeGap+=+internalNodeGap/2;

++++++++++++boolean+levelFirstNode+=+true;

++++++++++++while(!levelQueue.isEmpty())
++++++++++++{
++++++++++++++++internalNodeGap+=+copyinternalNodeGap;
++++++++++++++++Node+currNode+=+levelQueue.poll();
++++++++++++++++if(currNode+!=+null)
++++++++++++++++{
++++++++++++++++++++if(levelFirstNode)
++++++++++++++++++++{
++++++++++++++++++++++++while(firstNodeGap+>+0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++System.out.format("%25s",+"+++");
++++++++++++++++++++++++++++firstNodeGap--;+
++++++++++++++++++++++++}
++++++++++++++++++++++++levelFirstNode+=false;
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++while(internalNodeGap>0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++internalNodeGap--;
++++++++++++++++++++++++++++System.out.format("%25s",+"+++");
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++System.out.format("%253d",currNode.data);
++++++++++++++++++++rootsQueue.add(currNode);
++++++++++++++++}
++++++++++++}

++++++++++++--treeHeight;

++++++++++++while(!rootsQueue.isEmpty())
++++++++++++{
++++++++++++++++Node+currNode+=+rootsQueue.poll();
++++++++++++++++if(currNode+!=+null)
++++++++++++++++{
++++++++++++++++++++levelQueue.add(currNode.left);
++++++++++++++++++++levelQueue.add(currNode.right);
++++++++++++++++}
++++++++++++}

++++++++++++if(levelQueue.isEmpty())+break;
++++++++}

++++}|1005974|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Print in Console: 

<pre><code> 500
 700 300 
 200 400 
</code></pre>

Simple code :

<pre><code>public int getHeight()
 {
 if(rootNode == null) return -1;
 return getHeight(rootNode);
 }

 private int getHeight(Node node)
 {
 if(node == null) return -1;

 return Math.max(getHeight(node.left), getHeight(node.right)) + 1;
 }

 public void printBinaryTree(Node rootNode)
 {
 Queue&lt;Node&gt; rootsQueue = new LinkedList&lt;Node&gt;();
 Queue&lt;Node&gt; levelQueue = new LinkedList&lt;Node&gt;();
 levelQueue.add(rootNode);
 int treeHeight = getHeight();
 int firstNodeGap;
 int internalNodeGap;
 int copyinternalNodeGap;
 while(true)
 {
 System.out.println("");
 internalNodeGap = (int)(Math.pow(2, treeHeight + 1) -1); 
 copyinternalNodeGap = internalNodeGap;
 firstNodeGap = internalNodeGap/2;

 boolean levelFirstNode = true;

 while(!levelQueue.isEmpty())
 {
 internalNodeGap = copyinternalNodeGap;
 Node currNode = levelQueue.poll();
 if(currNode != null)
 {
 if(levelFirstNode)
 {
 while(firstNodeGap &gt; 0)
 {
 System.out.format("%s", " ");
 firstNodeGap--; 
 }
 levelFirstNode =false;
 }
 else
 {
 while(internalNodeGap&gt;0)
 {
 internalNodeGap--;
 System.out.format("%s", " ");
 }
 }
 System.out.format("%3d",currNode.data);
 rootsQueue.add(currNode);
 }
 }

 --treeHeight;

 while(!rootsQueue.isEmpty())
 {
 Node currNode = rootsQueue.poll();
 if(currNode != null)
 {
 levelQueue.add(currNode.left);
 levelQueue.add(currNode.right);
 }
 }

 if(levelQueue.isEmpty()) break;
 }

 }
</code></pre>

blocks|key|792078|text|这是一个非常通用的树打印机。不是最好看的，但它能处理很多案例。如果你能解决这个问题，你可以随意添加斜杠。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792079|📷|atomic|offset|length|792080|​|792081|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%2B%2B){
++++++++++++//sep+%2B=+"+";
++++++++}
++++}

++++private+void+setDepth(PrintableNode+info,+int+depth){
++++++++if+(depth+>+this.depth){
++++++++++++this.depth+=+depth;
++++++++}
++++++++if+(info._getLeftChild()+!=+null){
++++++++++++this.setDepth(info._getLeftChild(),depth%2B1);
++++++++}
++++++++if+(info._getRightChild()+!=+null){
++++++++++++this.setDepth(info._getRightChild(),depth%2B1);
++++++++}
++++}

++++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%2B%2B;

++++++++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%2Boffset);
++++++++}
++++}

++++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%2BmaxColumnsRight%2B1;
++++++++int+level+=+0;
++++++++String+node_format+=+"%25-"%2Bthis.maxTitleLength%2B"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%2B1;i%2B%2B){
++++++++++++++++String+value_i+=+i+<+chars.length+?+chars[i]:null;
++++++++++++++++if+(chars.length+%2B+1+==+i+%7C%7C+value_i+!=+null){
++++++++++++++++++++if+(empty_chars+>+0)+{
++++++++++++++++++++++++System.out.print(String.format("%25-"+%2B+empty_chars+%2B+"s",+"+"));
++++++++++++++++++++}
++++++++++++++++++++if+(value_i+!=+null){
++++++++++++++++++++++++System.out.print(String.format(node_format,value_i));
++++++++++++++++++++++++empty_chars+=+-1;
++++++++++++++++++++}+else{
++++++++++++++++++++++++empty_chars+=+0;
++++++++++++++++++++}
++++++++++++++++}+else+{
++++++++++++++++++++empty_chars%2B%2B;
++++++++++++++++}
++++++++++++}
++++++++++++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%2B%2B){
++++++++++++++++System.out.println("");
++++++++++++}


++++++++++++level%2B%2B;
++++++++}
++++}

++++private+String[]+getCharactersArray(List<PrintableNodePosition>+nodes,+int+max_chars){
++++++++String[]+positions+=+new+String[max_chars%2B1];
++++++++for+(PrintableNodePosition+a+:+nodes){
++++++++++++int+pos_i+=+maxColumnsLeft+%2B+a.column;
++++++++++++String+title_i+=+a.nodeInfo.getTitleFormatted(this.maxTitleLength);
++++++++++++positions[pos_i]+=+title_i;
++++++++}
++++++++return+positions;
++++}
}|code-block|syntax|javascript|792082|NodeInfo类|792083|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%2Btitle%2BCLI_PRINT_COLOR.RESET;
++++++++/*
++++++++String+title+=+this.title.length()+>+max_chars+?+this.title.substring(0,max_chars%2B1):this.title;
++++++++boolean+left+=+true;
++++++++while(title.length()+<+max_chars){
++++++++++++if+(left){
++++++++++++++++title+=+"+"%2Btitle;
++++++++++++}+else+{
++++++++++++++++title+=+title+%2B+"+";
++++++++++++}
++++++++}
++++++++return+this.textColor%2Btitle%2BCLI_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();
++++}
}|792084|NodePosition类|792085|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);
++++}
}|792086|最后，Node接口|792087|package+com.tomac120.NodePrinter;

/**
+*+Created+by+elijah+on+6/28/16.
+*/
public+interface+PrintableNode+{
++++PrintableNodeInfo+_getPrintableNodeInfo();
++++PrintableNode+_getLeftChild();
++++PrintableNode+_getRightChild();
}|792088|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/86b11626a5e546f8635b84f749c3aa6b.png|imageAlt^0|0|0|1|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@$E|1A|F|1B|1|1C]]|A|$]]|$1|G|3|H|5|6|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1E|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|1F|8|@]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1G|8|@]|9|@]|A|$L|M]]|$1|R|3|S|5|6|7|1H|8|@]|9|@]|A|$]]|$1|T|3|U|5|K|7|1I|8|@]|9|@]|A|$L|M]]|$1|V|3|W|5|6|7|1J|8|@]|9|@]|A|$]]|$1|X|3|Y|5|K|7|1K|8|@]|9|@]|A|$L|M]]|$1|Z|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|10|$11|$5|12|13|14|A|$15|16|17|-4]]]]

Here's a very versatile tree printer. Not the best looking, but it handles a lot of cases. Feel free to add slashes if you can figure that out.
<a href="https://i.stack.imgur.com/Glo7T.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Glo7T.png" alt="enter image description here"></a>

<pre><code>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&lt;List&lt;PrintableNodePosition&gt;&gt; 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&lt;&gt;(depth);
 this.addNode(rootNode._getPrintableNodeInfo(),0,0);
 for (int i = 0;i&lt;chars_per_node;i++){
 //sep += " ";
 }
 }

 private void setDepth(PrintableNode info, int depth){
 if (depth &gt; 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 &lt; 0 &amp;&amp; -position &gt; maxColumnsLeft){
 maxColumnsLeft = -position;
 }
 if (position &gt; 0 &amp;&amp; position &gt; maxColumnsRight){
 maxColumnsRight = position;
 }
 if (node.getTitleLength() &gt; maxTitleLength){
 maxTitleLength = node.getTitleLength();
 }
 List&lt;PrintableNodePosition&gt; 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&lt;PrintableNodePosition&gt; getRow(int row){
 if (row &gt; nodesByRow.size() - 1){
 nodesByRow.add(new LinkedList&lt;&gt;());
 }
 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&lt;PrintableNodePosition&gt; pos_arr : this.nodesByRow){
 String[] chars = this.getCharactersArray(pos_arr,max_chars);
 String line = "";
 int empty_chars = 0;
 for (int i=0;i&lt;chars.length+1;i++){
 String value_i = i &lt; chars.length ? chars[i]:null;
 if (chars.length + 1 == i || value_i != null){
 if (empty_chars &gt; 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&lt;line_offset;i++){
 System.out.println("");
 }


 level++;
 }
 }

 private String[] getCharactersArray(List&lt;PrintableNodePosition&gt; 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;
 }
}
</code></pre>

NodeInfo class

<pre><code>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() &gt; max_chars ? this.title.substring(0,max_chars+1):this.title;
 boolean left = true;
 while(title.length() &lt; 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();
 }
}
</code></pre>

NodePosition class

<pre><code>package com.tomac120.NodePrinter;

/**
 * Created by elijah on 6/28/16.
 */
public class PrintableNodePosition implements Comparable&lt;PrintableNodePosition&gt; {
 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);
 }
}
</code></pre>

And, finally, Node Interface

<pre><code>package com.tomac120.NodePrinter;

/**
 * Created by elijah on 6/28/16.
 */
public interface PrintableNode {
 PrintableNodeInfo _getPrintableNodeInfo();
 PrintableNode _getLeftChild();
 PrintableNode _getRightChild();
}
</code></pre>

blocks|key|792117|text|一个Scala解决方案，改编自Vasya+Novikov的答案，专门用于二叉树：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792118|/**+An+immutable+Binary+Tree.+*/
case+class+BTree[T](value:+T,+left:+Option[BTree[T]],+right:+Option[BTree[T]])+{

++/*+Adapted+from:+http://stackoverflow.com/a/8948691/643684+*/
++def+pretty:+String+=+{
++++def+work(tree:+BTree[T],+prefix:+String,+isTail:+Boolean):+String+=+{
++++++val+(line,+bar)+=+if+(isTail)+("└──+",+"+")+else+("├──+",+"│")

++++++val+curr+=+s"${prefix}${line}${tree.value}"

++++++val+rights+=+tree.right+match+{
++++++++case+None++++=>+s"${prefix}${bar}+++├──+∅"
++++++++case+Some(r)+=>+work(r,+s"${prefix}${bar}+++",+false)
++++++}

++++++val+lefts+=+tree.left+match+{
++++++++case+None++++=>+s"${prefix}${bar}+++└──+∅"
++++++++case+Some(l)+=>+work(l,+s"${prefix}${bar}+++",+true)
++++++}

++++++s"${curr}\n${rights}\n${lefts}"

++++}

++++work(this,+"",+true)
++}
}|code-block|syntax|javascript|792119|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A Scala solution, adapted from Vasya Novikov's answer and specialized for binary trees:

<pre><code>/** An immutable Binary Tree. */
case class BTree[T](value: T, left: Option[BTree[T]], right: Option[BTree[T]]) {

 /* Adapted from: http://stackoverflow.com/a/8948691/643684 */
 def pretty: String = {
 def work(tree: BTree[T], prefix: String, isTail: Boolean): String = {
 val (line, bar) = if (isTail) ("└── ", " ") else ("├── ", "│")

 val curr = s"${prefix}${line}${tree.value}"

 val rights = tree.right match {
 case None =&gt; s"${prefix}${bar} ├── ∅"
 case Some(r) =&gt; work(r, s"${prefix}${bar} ", false)
 }

 val lefts = tree.left match {
 case None =&gt; s"${prefix}${bar} └── ∅"
 case Some(l) =&gt; work(l, s"${prefix}${bar} ", true)
 }

 s"${curr}\n${rights}\n${lefts}"

 }

 work(this, "", true)
 }
}
</code></pre>

blocks|key|1006091|text|我发现VasyaNovikov的答案对于打印大型通用树非常有用，并将其修改为二叉树|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006092|代码：|1006093|class+TreeNode+{
++++Integer+data+=+null;
++++TreeNode+left+=+null;
++++TreeNode+right+=+null;

++++TreeNode(Integer+data)+{this.data+=+data;}

++++public+void+print()+{
++++++++print("",+this,+false);
++++}

++++public+void+print(String+prefix,+TreeNode+n,+boolean+isLeft)+{
++++++++if+(n+!=+null)+{
++++++++++++System.out.println+(prefix+%2B+(isLeft+?+"%7C--+"+:+"\\--+")+%2B+n.data);
++++++++++++print(prefix+%2B+(isLeft+?+"%7C+++"+:+"++++"),+n.left,+true);
++++++++++++print(prefix+%2B+(isLeft+?+"%7C+++"+:+"++++"),+n.right,+false);
++++++++}
++++}
}|code-block|syntax|javascript|1006094|示例输出：|1006095|\--+7
++++%7C--+3
++++%7C+++%7C--+1
++++%7C+++%7C+++\--+2
++++%7C+++\--+5
++++%7C+++++++%7C--+4
++++%7C+++++++\--+6
++++\--+11
++++++++%7C--+9
++++++++%7C+++%7C--+8
++++++++%7C+++\--+10
++++++++\--+13
++++++++++++%7C--+12
++++++++++++\--+14|1006096|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I found VasyaNovikov's answer very useful for printing a large general tree, and modified it for a binary tree

Code:

<pre><code>class TreeNode {
 Integer data = null;
 TreeNode left = null;
 TreeNode right = null;

 TreeNode(Integer data) {this.data = data;}

 public void print() {
 print("", this, false);
 }

 public void print(String prefix, TreeNode n, boolean isLeft) {
 if (n != null) {
 System.out.println (prefix + (isLeft ? "|-- " : "\\-- ") + n.data);
 print(prefix + (isLeft ? "| " : " "), n.left, true);
 print(prefix + (isLeft ? "| " : " "), n.right, false);
 }
 }
}
</code></pre>

Sample output:

<pre><code>\-- 7
 |-- 3
 | |-- 1
 | | \-- 2
 | \-- 5
 | |-- 4
 | \-- 6
 \-- 11
 |-- 9
 | |-- 8
 | \-- 10
 \-- 13
 |-- 12
 \-- 14
</code></pre>

blocks|key|1006184|text|这是另一种可视化树的方法:将节点保存为xml文件，然后让浏览器显示层次结构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006185|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='"+%2B+key+%2B+"'+dir='"+%2B+dir+%2B+"'>");
++++++++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){

++++++++}
++++}
}|code-block|syntax|javascript|1006186|下面是测试它的代码：|1006187|++++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();|1006188|输出如下所示：|1006189|​|1006190|📷|atomic|offset|length|1006191|1006192|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/d469c3e501bc522636ce87b4b7e211b4.png|imageAlt^0|0|0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|19|8|@]|9|@$R|1A|S|1B|1|1C]]|A|$]]|$1|T|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11|12|-4]]]]

Here is another way to visualize your tree: save the nodes as an xml file and then let your browser show you the hierarchy:

<pre><code>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("&lt;node key='" + key + "' dir='" + dir + "'&gt;");
 if(left != null)
 left.printNode(output, "l");
 if(right != null)
 right.printNode(output, "r");
 output.append("&lt;/node&gt;");
 }
}

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 &lt; root.key)
 root.left = insert(root.left, key);
 else if(key &gt; root.key)
 root.right = insert(root.right, key);

 return root;
 }

 public void saveTreeAsXml(){
 StringBuilder strOutput = new StringBuilder();
 strOutput.append("&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;");
 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){

 }
 }
}
</code></pre>

Here is code to test it:

<pre><code> 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();
</code></pre>

And the output looks like this:

<a href="https://i.stack.imgur.com/nbG70.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/nbG70.png" alt="enter image description here"></a>

blocks|key|792321|text|基于VasyaNovikov应答。通过一些Java魔术进行了改进:泛型和函数接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792322|/**
+*+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+%2B+nodeConnection+%2B+nodeName);
++++List<T>+children+=+getChildrenFunc.apply(node);
++++for+(int+i+=+0;+i+<+children.size();+i%2B%2B)+{
++++++++String+newPrefix+=+prefix+%2B+(isTail+?+"++++"+:+"│+++");
++++++++printTreeRec(newPrefix,+children.get(i),+getChildrenFunc,+i+==+children.size()-1);
++++}
}|code-block|syntax|javascript|792323|初始呼叫示例：|792324|Function<ChecksumModel,+List<ChecksumModel>>+getChildrenFunc+=+node+->+getChildrenOf(node)
printTreeRec("",+rootNode,+getChildrenFunc,+true);|792325|将输出类似于|792326|└──+rootNode
++++├──+childNode1
++++├──+childNode2
++++│+++├──+childNode2.1
++++│+++├──+childNode2.2
++++│+++└──+childNode2.3
++++├──+childNode3
++++└──+childNode4|792327|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Based on VasyaNovikov answer. Improved with some Java magic: Generics and Functional interface.

<pre><code>/**
 * 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 &lt;T&gt; The type of your nodes. Anything that has a toString can be used.
 */
private &lt;T&gt; void printTreeRec(String prefix, T node, Function&lt;T, List&lt;T&gt;&gt; getChildrenFunc, boolean isTail) {
 String nodeName = node.toString();
 String nodeConnection = isTail ? "└── " : "├── ";
 log.debug(prefix + nodeConnection + nodeName);
 List&lt;T&gt; children = getChildrenFunc.apply(node);
 for (int i = 0; i &lt; children.size(); i++) {
 String newPrefix = prefix + (isTail ? " " : "│ ");
 printTreeRec(newPrefix, children.get(i), getChildrenFunc, i == children.size()-1);
 }
}
</code></pre>

Example initial call:

<pre><code>Function&lt;ChecksumModel, List&lt;ChecksumModel&gt;&gt; getChildrenFunc = node -&gt; getChildrenOf(node)
printTreeRec("", rootNode, getChildrenFunc, true);
</code></pre>

Will output something like

<pre><code>└── rootNode
 ├── childNode1
 ├── childNode2
 │ ├── childNode2.1
 │ ├── childNode2.2
 │ └── childNode2.3
 ├── childNode3
 └── childNode4
</code></pre>

blocks|key|1006319|text|这是水平视图最简单的解决方案。尝试了一大堆例子。对我来说效果很好。从@nitin-k的答案更新。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1006320|public+void+print(String+prefix,+BTNode+n,+boolean+isLeft)+{
++++if+(n+!=+null)+{
++++++++print(prefix+%2B+"+++++",+n.right,+false);
++++++++System.out.println+(prefix+%2B+("%7C--+")+%2B+n.data);
++++++++print(prefix+%2B+"+++++",+n.left,+true);
++++}
}|code-block|syntax|javascript|1006321|呼叫：|1006322|bst.print("",+bst.root,+false);|1006323|解决方案：|1006324|+++++++++++++++++++++++++%7C--+80
++++++++++++++++++++%7C--+70
+++++++++++++++%7C--+60
++++++++++%7C--+50
+++++%7C--+40
%7C--+30
+++++%7C--+20
++++++++++%7C--+10|1006325|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This was the simplest solution for horizontal view. Tried with bunch of examples. Works well for my purpose. Updated from @nitin-k 's answer.

<pre><code>public void print(String prefix, BTNode n, boolean isLeft) {
 if (n != null) {
 print(prefix + " ", n.right, false);
 System.out.println (prefix + ("|-- ") + n.data);
 print(prefix + " ", n.left, true);
 }
}
</code></pre>

Call:

<pre><code>bst.print("", bst.root, false);
</code></pre>

Solution:

<pre><code> |-- 80
 |-- 70
 |-- 60
 |-- 50
 |-- 40
|-- 30
 |-- 20
 |-- 10
</code></pre>

blocks|key|792399|text|using+map...
{
Map<Integer,String>+m+=+new+LinkedHashMap<>();

+++++++++tn.printNodeWithLvl(node,l,m);

++++++++for(Entry<Integer,+String>+map+:m.entrySet())+{
++++++++++++System.out.println(map.getValue());
++++++++}
then....method


+++private++void+printNodeWithLvl(Node+node,int+l,Map<Integer,String>+m)+{
+++++++if(node==null)+{
+++++++++++return;
+++++++}
++++++if(m.containsKey(l))+{
++++++++++m.put(l,+new+StringBuilder(m.get(l)).append(node.value).toString());
++++++}else+{
++++++++++m.put(l,+node.value%2B"");
++++++}
++++++l%2B%2B;
++++++printNodeWithLvl(+node.left,l,m);
++++++printNodeWithLvl(node.right,l,m);

++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|792400|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>using map...
{
Map&lt;Integer,String&gt; m = new LinkedHashMap&lt;&gt;();

 tn.printNodeWithLvl(node,l,m);

 for(Entry&lt;Integer, String&gt; map :m.entrySet()) {
 System.out.println(map.getValue());
 }
then....method


 private void printNodeWithLvl(Node node,int l,Map&lt;Integer,String&gt; m) {
 if(node==null) {
 return;
 }
 if(m.containsKey(l)) {
 m.put(l, new StringBuilder(m.get(l)).append(node.value).toString());
 }else {
 m.put(l, node.value+"");
 }
 l++;
 printNodeWithLvl( node.left,l,m);
 printNodeWithLvl(node.right,l,m);

 }
}
</code></pre>

How can I print a binary tree in Java so that the output is like:

<pre><code> 4 
 / \ 
 2 5 
</code></pre>

My node:

<pre><code>public class Node&lt;A extends Comparable&gt; {
 Node&lt;A&gt; left, right;
 A data;

 public Node(A data){
 this.data = data;
 }
}
</code></pre>

How to print binary tree diagram in Java?

Java

如何在Java中打印二叉树，以便输出如下所示： 4 / \ 2 5 我的节点：public class Node<A extends Comparable> { Node<A> left, right; A data; public Node(A data){ this.d...

问如何在Java中打印二叉树图？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中打印二叉树图？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中打印二叉树图？
EN