Çıktıya benzer şekilde Java'daki bir ikili ağacı nasıl yazdırabilirim:
4
/ \
2 5
Düğümüm:
public class Node<A extends Comparable> {
Node<A> left, right;
A data;
public Node(A data){
this.data = data;
}
}
Çıktıya benzer şekilde Java'daki bir ikili ağacı nasıl yazdırabilirim:
4
/ \
2 5
Düğümüm:
public class Node<A extends Comparable> {
Node<A> left, right;
A data;
public Node(A data){
this.data = data;
}
}
Yanıtlar:
Basit ikili ağaç yazıcısı oluşturdum. İstediğiniz gibi kullanabilir ve değiştirebilirsiniz, ancak yine de optimize edilmemiştir. Burada bir çok şeyin geliştirilebileceğini düşünüyorum;)
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() || 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<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++) {
for (int j = 0; j < 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 < count; i++)
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)) + 1;
}
private static <T> boolean isAllElementsNull(List<T> list) {
for (Object object : list) {
if (object != null)
return false;
}
return true;
}
}
Çıkış 1:
2
/ \
/ \
/ \
/ \
7 5
/ \ / \
/ \ / \
2 6 3 6
/ \ / \ / \ / \
5 8 4 5 8 4 5 8
Çıkış 2:
2
/ \
/ \
/ \
/ \
7 5
/ \ \
/ \ \
2 6 9
/ \ /
5 8 4
[Büyük] bir ağacı satır satır yazdırın.
çıktı örneği:
z
├── c
│ ├── a
│ └── b
├── d
├── e
│ └── asdf
└── f
kod:
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 + "├── ", childrenPrefix + "│ ");
} else {
next.print(buffer, childrenPrefix + "└── ", childrenPrefix + " ");
}
}
}
}
Not: Bu cevap tam olarak "ikili" ağaçlara odaklanmaz - bunun yerine her türlü ağacı basar. Çözüm, linux'daki "tree" komutundan esinlenmiştir.
children.get(children.size() - 1)
HashMap çocuklar için kullanıldıysa nasıl yeniden yazardınız ? Bunun dışında her parçayı değiştirmeyi başardım.
HashMap<String, List<String>>
?
HashMap<String, Node>
. Dize Düğümün kimliğidir.
Bunun için farklı boyutlarda güzel düğümleri işleyen gelişmiş bir algoritma yaptım. Çizgileri kullanarak yukarıdan aşağıya yazdırır.
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++;
if (n.getRight() != null) nn++;
}
}
if (widest % 2 == 1) widest++;
lines.add(line);
List<PrintableNode> tmp = level;
level = next;
next = tmp;
next.clear();
}
int perpiece = lines.get(lines.size() - 1).size() * (widest + 4);
for (int i = 0; i < lines.size(); i++) {
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++) {
// split node
char c = ' ';
if (j % 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++) {
System.out.print(" ");
}
} else {
for (int k = 0; k < hpw; k++) {
System.out.print(j % 2 == 0 ? " " : "─");
}
System.out.print(j % 2 == 0 ? "┌" : "┐");
for (int k = 0; k < hpw; k++) {
System.out.print(j % 2 == 0 ? "─" : " ");
}
}
}
System.out.println();
}
// print line of numbers
for (int j = 0; j < 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 < gap1; k++) {
System.out.print(" ");
}
System.out.print(f);
for (int k = 0; k < gap2; k++) {
System.out.print(" ");
}
}
System.out.println();
perpiece /= 2;
}
}
}
Bunu Ağacınız için kullanmak için Node
sınıfınızın uygulanmasına izin verin PrintableNode
.
Örnek çıktı:
2952:0
┌───────────────────────┴───────────────────────┐
1249:-1 5866:0
┌───────────┴───────────┐ ┌───────────┴───────────┐
491:-1 1572:0 4786:1 6190:0
┌─────┘ └─────┐ ┌─────┴─────┐
339:0 5717:0 6061:0 6271:0
???????????
Düğümler arasındaki çizgiler yerine ama sadece bazı UTF8 ans malzeme sorunu olmalıdır. Her neyse, harika şeyler, söylemeliyim. Kullanımı gerçekten kolay olduğu için benim için en iyi cevap.
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 + (isRight ? " " : " | "));
}
out.write(indent);
if (isRight) {
out.write(" /");
} else {
out.write(" \\");
}
out.write("----- ");
printNodeValue(out);
if (left != null) {
left.printTree(out, false, indent + (isRight ? " | " : " "));
}
}
}
yazdıracak:
/----- 20
| \----- 15
/----- 14
| \----- 13
/----- 12
| | /----- 11
| \----- 10
| \----- 9
8
| /----- 7
| /----- 6
| | \----- 5
\----- 4
| /----- 3
\----- 2
\----- 1
giriş için
8 4 12 2 6 10 14 1 3 5 7 9 11 13 20 15
bu @ anurag'ın cevabından bir varyant - ekstra | s'ı görmek beni rahatsız ediyordu
Uyarlanmış Vasya Novikov 'ın cevabı daha yapmak için ikili ve kullanımıStringBuilder
verimliliği için (birleştirerek String
Java birlikte nesneleri genellikle verimsiz).
public StringBuilder toString(StringBuilder prefix, boolean isTail, StringBuilder sb) {
if(right!=null) {
right.toString(new StringBuilder().append(prefix).append(isTail ? "│ " : " "), false, sb);
}
sb.append(prefix).append(isTail ? "└── " : "┌── ").append(value.toString()).append("\n");
if(left!=null) {
left.toString(new StringBuilder().append(prefix).append(isTail ? " " : "│ "), true, sb);
}
return sb;
}
@Override
public String toString() {
return this.toString(new StringBuilder(), true, new StringBuilder()).toString();
}
Çıktı:
│ ┌── 7
│ ┌── 6
│ │ └── 5
└── 4
│ ┌── 3
└── 2
└── 1
└── 0
right != null
Düzenlemeyi yaptığımda ve test ettiğimde isTail değeri yanlış olmalı , iyi çalışıyor.
michal.kreuzman güzel bir söylemek zorunda kalacak.
Kendim tarafından bir program yapmak için tembel hissediyordum ve bu gerçekten bana yardımcı oldu buldum zaman net kod arıyor.
Ancak, yalnızca tek basamaklar için birden fazla basamak kullanacaksınız gibi çalıştığından korkuyorum, çünkü boşluk kullanıyorsunuz ve sekmeler kullanmıyorsunuz, yapı yanlış yerleştirilecek ve program kullanımını kaybedecek.
Daha sonraki kodlarım için bazı büyük girişlere (en az 10'dan fazla) ihtiyacım vardı, bu benim için işe yaramadı ve bir şey bulamadığımda net bir çok şey aradıktan sonra kendim bir program yaptım.
Şimdi bazı hatalar var, yine şu anda onları düzeltmek için tembel hissediyorum ama çok güzel yazdırır ve düğümleri büyük bir değer alabilir.
Ağaç sorudan bahsetmeyecek ama 270 derece döndürülecek :)
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<level-1;i++)
System.out.print("|\t");
System.out.println("|-------"+root.val);
}
else
System.out.println(root.val);
printBinaryTree(root.left, level+1);
}
Bu işlevi kendi belirtilen TreeNode'unuzla yerleştirin ve düzeyi başlangıçta 0 olarak tutun ve tadını çıkarın!
İşte bazı örnek çıktılar:
| | |-------11
| |-------10
| | |-------9
|-------8
| | |-------7
| |-------6
| | |-------5
4
| |-------3
|-------2
| |-------1
| | | |-------10
| | |-------9
| |-------8
| | |-------7
|-------6
| |-------5
4
| |-------3
|-------2
| |-------1
Tek sorun uzanan dallarla ilgilidir; Sorunu en kısa sürede çözmeye çalışacağım, ancak o zamana kadar da kullanabilirsiniz.
Ağacınızın her katman için iki kat uzaklığa ihtiyacı olacaktır:
bir / \ / \ / \ / \ M.Ö / \ / \ / \ / \ defg / \ / \ / \ / \ hijklmno
Ağacınızı her derinlik için bir dizi olmak üzere bir dizi diziye kaydedebilirsiniz:
[[A] [b, c] [d, e, f, g], [h, i, j, k, l, m, n, o]]
Ağacınız dolu değilse, bu diziye boş değerler eklemeniz gerekir:
bir / \ / \ / \ / \ M.Ö / \ / \ / \ / \ defg / \ \ / \ \ hiklmo [[a], [b, c], [d, e, f, g], [h, i,, k, l, m,,]]
Daha sonra ağacınızı yazdırmak, ilk öğeden önce ve derinliğe bağlı olarak öğeler arasında boşluklar yazdırmak ve bir sonraki katman için dizideki karşılık gelen öğelerin doldurulup doldurulmamasına bağlı olarak satırları yazdırmak için dizi üzerinde yineleme yapabilirsiniz. Değerleriniz birden fazla karakter uzunluğunda olabiliyorsa, dizi temsilini oluştururken en uzun değeri bulmanız ve tüm genişlikleri ve satır sayısını buna göre çarpmanız gerekir.
VasyaNovikov'un cevabını büyük bir genel ağaç yazdırmak için çok yararlı buldum ve ikili bir ağaç için değiştirdim
Kod:
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);
}
}
}
Örnek çıktı:
\-- 7
|-- 3
| |-- 1
| | \-- 2
| \-- 5
| |-- 4
| \-- 6
\-- 11
|-- 9
| |-- 8
| \-- 10
\-- 13
|-- 12
\-- 14
Java dilinde yazdıklarıma benzer Scala dilinde bir çözüm :
case class Node(name: String, children: Node*) {
def toTree: String = toTree("", "").mkString("\n")
private def toTree(prefix: String, childrenPrefix: String): Seq[String] = {
val firstLine = prefix + this.name
val firstChildren = this.children.dropRight(1).flatMap { child =>
child.toTree(childrenPrefix + "├── ", childrenPrefix + "│ ")
}
val lastChild = this.children.takeRight(1).flatMap { child =>
child.toTree(childrenPrefix + "└── ", childrenPrefix + " ")
}
firstLine +: firstChildren ++: lastChild
}
}
Çıktı örneği:
vasya
├── frosya
│ ├── petya
│ │ └── masha
│ └── kolya
└── frosya2
Hepinizin harika bir çözümü olduğunu biliyorum; Sadece benimkini paylaşmak istiyorum - belki de bu en iyi yol değil, ama kendim için mükemmel!
İle python
ve pip
üzerinde, bu gerçekten oldukça basit! BOOM!
Mac veya Ubuntu'da (benimki mac)
$ pip install drawtree
$python
, python konsolunu girin; başka şekilde yapabilirsinfrom drawtree import draw_level_order
draw_level_order('{2,1,3,0,7,9,1,2,#,1,0,#,#,8,8,#,#,#,#,7}')
YAPILAN!
2
/ \
/ \
/ \
1 3
/ \ / \
0 7 9 1
/ / \ / \
2 1 0 8 8
/
7
Kaynak Takibi:
Bu yazıyı görmeden önce google "ikili ağaç düz metin"
Ve bunu buldum https://www.reddit.com/r/learnpython/comments/3naiq8/draw_binary_tree_in_plain_text/ , beni bu https://github.com/msbanik/drawtree adresine yönlendirin
java
bir Java yanıtı beklerken soruyu etiketlediğinde :)
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
Bu bir ağacı yazdırmak için çok basit bir çözümdür. O kadar güzel değil, ama gerçekten basit:
enum { kWidth = 6 };
void PrintSpace(int n)
{
for (int i = 0; i < n; ++i)
printf(" ");
}
void PrintTree(struct Node * root, int level)
{
if (!root) return;
PrintTree(root->right, level + 1);
PrintSpace(level * kWidth);
printf("%d", root->data);
PrintTree(root->left, level + 1);
}
Örnek çıktı:
106 105 104 103 102 101 100
VasyaNovikov cevabına dayanarak. Bazı Java sihirleriyle geliştirildi: Jenerikler ve Fonksiyonel arayüz.
/**
* 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);
}
}
Örnek ilk çağrı:
Function<ChecksumModel, List<ChecksumModel>> getChildrenFunc = node -> getChildrenOf(node)
printTreeRec("", rootNode, getChildrenFunc, true);
Gibi bir şey çıktı olacak
└── rootNode
├── childNode1
├── childNode2
│ ├── childNode2.1
│ ├── childNode2.2
│ └── childNode2.3
├── childNode3
└── childNode4
Java'da bir ikili ağaç yazıcısı yazdım.
Kod GitHub'da burada .
Çalışma süresi verimliliği için optimize edilmedi, ancak ASCII'de baskı hakkında konuştuğumuzdan, bunun çok büyük ağaçlarda kullanılmayacağını düşündüm. Gerçi bazı güzel özellikleri var.
Bazı demo / test programları dahildir.
Program tarafından yazdırılan rastgele oluşturulmuş bir ikili ağaç örneği aşağıdadır. Bu, küçük bir sol alt ağaç altında uzanan büyük bir sağ alt ağaç ile alanın verimli kullanımını gösterir:
seven
/ \
/ \
/ \
/ \
/ \
/ \
five thirteen
/ \ / \
/ \ / \
/ \ / \
three six / \
/ \ / \
/ \ / \
one four / \
\ / \
two / \
nine twenty four
/ \ / \
/ \ / \
/ \ / \
eight twelve / \
/ / \
ten / \
\ / \
eleven / \
/ \
/ \
/ \
eighteen twenty seven
/ \ / \
/ \ / \
/ \ / \
/ \ / \
/ \ / \
/ \ / \
/ \ twenty five twenty eight
/ \ \ \
/ \ twenty six thirty
fourteen nineteen /
\ \ twenty nine
sixteen twenty three
/ \ /
/ \ twenty two
/ \ /
/ \ twenty
/ \ \
fifteen seventeen twenty one
Beş düğüm ikili ağacının tümünü (sıralı etiketlerle) sayfa boyunca yazdırma örneği:
one one one one one one one
\ \ \ \ \ \ \
two two two two two three three
\ \ \ \ \ / \ / \
three three four five five two four two five
\ \ / \ / / \ /
four five / \ three four five four
\ / three five \ /
five four four three
one one one one one one one two
\ \ \ \ \ \ \ / \
four four five five five five five / \
/ \ / \ / / / / / one three
two five / \ two two three four four \
\ three five \ \ / \ / / four
three / three four two four two three \
two \ / \ / five
four three three two
two two two two three three three
/ \ / \ / \ / \ / \ / \ / \
/ \ one four one five one five one four / \ two four
one three / \ / / \ \ / \ / \
\ / \ three four two five one five one five
five three five \ / \ /
/ four three two four
four
three four four four four four five
/ \ / \ / \ / \ / \ / \ /
two five one five one five two five / \ / \ one
/ / \ \ / \ three five three five \
one four two three / \ / / two
\ / one three one two \
three two \ / three
two one \
four
five five five five five five five five
/ / / / / / / /
one one one one two two three three
\ \ \ \ / \ / \ / \ / \
two three four four / \ one four one four two four
\ / \ / / one three / \ /
four two four two three \ three two one
/ \ / four
three three two
five five five five five
/ / / / /
four four four four four
/ / / / /
one one two three three
\ \ / \ / /
two three / \ one two
\ / one three \ /
three two two one
Aşağıda, 1 ve 3 yatay aralıklarla ve diyagonal ve yatay dallarla 4 farklı şekilde basılmış aynı ağacın bir örneği yer almaktadır.
27
┌─────┴─────┐
13 29
┌──────┴──────┐ ┌─┴─┐
8 23 28 30
┌──┴──┐ ┌──┴──┐
4 11 21 26
┌─┴─┐ ┌┴┐ ┌─┴─┐ ┌┘
2 5 9 12 18 22 24
┌┴┐ └┐ └┐ ┌─┴─┐ └┐
1 3 6 10 17 19 25
└┐ ┌┘ └┐
7 15 20
┌─┴─┐
14 16
27
/ \
/ \
13 29
/ \ / \
/ \ 28 30
/ \
/ \
/ \
/ \
8 23
/ \ / \
/ \ / \
4 11 / \
/ \ / \ 21 26
2 5 9 12 / \ /
/ \ \ \ 18 22 24
1 3 6 10 / \ \
\ 17 19 25
7 / \
15 20
/ \
14 16
27
┌────────┴────────┐
13 29
┌─────────┴─────────┐ ┌──┴──┐
8 23 28 30
┌────┴────┐ ┌────┴────┐
4 11 21 26
┌──┴──┐ ┌─┴─┐ ┌──┴──┐ ┌┘
2 5 9 12 18 22 24
┌─┴─┐ └┐ └┐ ┌──┴──┐ └┐
1 3 6 10 17 19 25
└┐ ┌┘ └┐
7 15 20
┌──┴──┐
14 16
27
/ \
/ \
/ \
/ \
13 29
/ \ / \
/ \ / \
/ \ 28 30
/ \
/ \
/ \
/ \
/ \
8 23
/ \ / \
/ \ / \
/ \ / \
4 11 / \
/ \ / \ 21 26
2 5 9 12 / \ /
/ \ \ \ / \ 24
1 3 6 10 18 22 \
\ / \ 25
7 / \
17 19
/ \
15 20
/ \
/ \
14 16
@Makyen
bir yorum ekleyerek bana burada ping atın .
Bu ilginç bir soru ve ben de bunun için bir proje yazdım.
İşte bazı örnekler:
Rastgele BST yazdırın.
BTPrinter.printRandomBST(100, 100);
38
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
28 82
/ \ / \
/ \ / \
/ \ / \
/ \ / \
5 31 / \
/ \ / \ / \
/ \ 30 36 / \
/ \ / / \ / \
/ \ 29 33 37 / \
/ \ / \ / \
/ \ 32 35 65 95
1 14 / / \ / \
/ \ / \ 34 / \ 94 97
0 2 / \ / \ / / \
\ 12 24 / \ 93 96 98
3 / \ / \ / \ / \
\ 9 13 16 25 / \ 84 99
4 / \ / \ \ / \ / \
7 10 15 23 26 59 74 83 86
/ \ \ / \ / \ / \ / \
6 8 11 22 27 56 60 73 76 85 91
/ / \ \ / / \ / \
20 / \ 61 67 75 79 88 92
/ \ 40 58 \ / \ / \ / \
18 21 / \ / 62 66 72 78 80 87 89
/ \ 39 54 57 \ / / \ \
17 19 / \ 64 69 77 81 90
50 55 / / \
/ \ 63 68 70
/ \ \
/ \ 71
47 53
/ \ /
/ \ 52
42 49 /
/ \ / 51
41 43 48
\
46
/
45
/
44
Leetcode stili düzey sırası dizisinden ağaç yazdır, '#' aşağıda düğümün bulunduğu bir yol sonlandırıcı anlamına gelir.
BTPrinter.printTree("1,2,3,4,5,#,#,6,7,8,1,#,#,#,#,#,#,2,3,4,5,6,7,8,9,10,11,12,13,14,15");
1
/ \
2 3
/ \
/ \
4 5
/ \ / \
6 7 8 1
/ \
/ \
/ \
/ \
/ \
2 3
/ \ / \
/ \ / \
4 5 6 7
/ \ / \ / \ / \
8 9 10 11 12 13 14 15
Projelerimden birinde bir ikili ağaç yazdırmam gerekiyordu, çünkü bir java sınıfı hazırladım TreePrinter
, örnek çıktılardan biri:
[+]
/ \
/ \
/ \
/ \
/ \
[*] \
/ \ [-]
[speed] [2] / \
[45] [12]
İşte sınıf TreePrinter
ile birlikte sınıf kodu TextNode
. Herhangi bir ağacı yazdırmak için TextNode
sınıfla eşdeğer bir ağaç oluşturabilirsiniz .
import java.util.ArrayList;
public class TreePrinter {
public TreePrinter(){
}
public static String TreeString(TextNode root){
ArrayList layers = new ArrayList();
ArrayList bottom = new ArrayList();
FillBottom(bottom, root); DrawEdges(root);
int height = GetHeight(root);
for(int i = 0; i s.length()) min = s.length();
if(!n.isEdge) s += "[";
s += n.text;
if(!n.isEdge) s += "]";
layers.set(n.depth, s);
}
StringBuilder sb = new StringBuilder();
for(int i = 0; i temp = new ArrayList();
for(int i = 0; i 0) temp.get(i-1).left = x;
temp.add(x);
}
temp.get(count-1).left = n.left;
n.left.depth = temp.get(count-1).depth+1;
n.left = temp.get(0);
DrawEdges(temp.get(count-1).left);
}
if(n.right != null){
int count = n.right.x - (n.x + n.text.length() + 2);
ArrayList temp = new ArrayList();
for(int i = 0; i 0) temp.get(i-1).right = x;
temp.add(x);
}
temp.get(count-1).right = n.right;
n.right.depth = temp.get(count-1).depth+1;
n.right = temp.get(0);
DrawEdges(temp.get(count-1).right);
}
}
private static void FillBottom(ArrayList bottom, TextNode n){
if(n == null) return;
FillBottom(bottom, n.left);
if(!bottom.isEmpty()){
int i = bottom.size()-1;
while(bottom.get(i).isEdge) i--;
TextNode last = bottom.get(i);
if(!n.isEdge) n.x = last.x + last.text.length() + 3;
}
bottom.add(n);
FillBottom(bottom, n.right);
}
private static boolean isLeaf(TextNode n){
return (n.left == null && n.right == null);
}
private static int GetHeight(TextNode n){
if(n == null) return 0;
int l = GetHeight(n.left);
int r = GetHeight(n.right);
return Math.max(l, r) + 1;
}
}
class TextNode {
public String text;
public TextNode parent, left, right;
public boolean isEdge;
public int x, depth;
public TextNode(String text){
this.text = text;
parent = null; left = null; right = null;
isEdge = false;
x = 0; depth = 0;
}
}
Son olarak, verilen örnek yazdırmak için bir test sınıfı:
public class Test {
public static void main(String[] args){
TextNode root = new TextNode("+");
root.left = new TextNode("*"); root.left.parent = root;
root.right = new TextNode("-"); root.right.parent = root;
root.left.left = new TextNode("speed"); root.left.left.parent = root.left;
root.left.right = new TextNode("2"); root.left.right.parent = root.left;
root.right.left = new TextNode("45"); root.right.left.parent = root.right;
root.right.right = new TextNode("12"); root.right.right.parent = root.right;
System.out.println(TreePrinter.TreeString(root));
}
}
Bunu kolayca görselleştirmek için bir uygulama kullanabilirsiniz. Aşağıdaki öğeleri yazdırmanız gerekir.
Düğümleri görünür yarıçapı olan daireler olarak yazdırın
Her düğüm için koordinatları alın.
X koordinatı, düğümün geçiş sırasında ziyaret edilmeden önce ziyaret edilen düğüm sayısı olarak görselleştirilebilir.
Y koordinatı, belirli düğümün derinliği olarak görselleştirilebilir.
Ebeveyn ve çocuk arasındaki satırları yazdırma
Bu, düğümlerin x ve y koordinatlarının ve her düğümün ebeveynlerinin ayrı listelerde tutulmasıyla yapılabilir.
Kök dışındaki her düğüm için, hem alt öğenin hem de üst öğenin x ve y koordinatlarını alarak her düğümü üst öğesiyle birleştirin.
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<slashes; i++, space --, spaceInBetween+=2) {
for(int j=0; j<space; j++) sb.append(" ");
sb.append(leftSlash);
for(int j=0; j<spaceInBetween; j++) sb.append(" ");
sb.append(rightSlash+"");
for(int j=0; j<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 <= 3) return height -1;
return (int) (3*Math.pow(2, height-3)-1);
}
https://github.com/murtraja/java-binary-tree-printer
sadece 1 ila 2 basamaklı tamsayılar için çalışır (genel yapmak için tembeltim)
Bu, yatay görünüm için en basit çözümdü. Bir sürü örnekle denedim. Amacım için iyi çalışıyor. @ Nitin-k tarafından verilen yanıttan güncellendi.
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);
}
}
Aramak:
bst.print("", bst.root, false);
Çözüm:
|-- 80
|-- 70
|-- 60
|-- 50
|-- 40
|-- 30
|-- 20
|-- 10
node_length * nodes_count + space_length * spaces_count*
.GitHub'da Kod: YoussefRaafatNasry / bst-ascii-visualization
07
/\
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
03 11
/\ /\
/ \ / \
/ \ / \
/ \ / \
/ \ / \
01 05 09 13
/\ /\ /\ /\
/ \ / \ / \ / \
00 02 04 06 08 10 12 14
visualize
işlev değil visualizer
, başlık dosyası da dahil olmak üzere yaklaşık 200 loc olan tüm sınıftır.
Rust çözümü arayanlar için:
pub struct Node {
pub value: i32,
left: Option<Box<Node>>,
right: Option<Box<Node>>
}
impl Node {
pub fn new(val: i32) -> Node {
Node {
value: val,
left: None,
right: None
}
}
pub fn getLeftNode(&self) -> Option<&Node> {
self.left.as_deref()
}
pub fn getRightNode(&self) -> Option<&Node> {
self.right.as_deref()
}
pub fn setLeftNode(&mut self, val: i32) -> &mut Node {
self.left = Some(Box::new(Node::new(val)));
self.left.as_deref_mut().unwrap()
}
pub fn setRightNode(&mut self, val: i32) -> &mut Node {
self.right = Some(Box::new(Node::new(val)));
self.right.as_deref_mut().unwrap()
}
fn visualizeTree(&self, level: u16, is_tail: bool, columns: &mut HashSet<u16>) {
let left = self.getLeftNode();
let right = self.getRightNode();
if right.is_some() {
right.unwrap().visualizeTree(level+1, false, columns);
}
if level > 0 {
for i in 0..level-1 {
if columns.contains(&i) {
print!("│ ");
} else {
print!(" ");
}
}
if is_tail {
println!("└── {}", self.value);
columns.remove(&(level-1));
columns.insert(level);
} else {
println!("┌── {}", self.value);
columns.insert(level);
columns.insert(level-1);
}
} else {
println!("{}", self.value);
}
if left.is_some() {
left.unwrap().visualizeTree(level+1, true, columns);
}
}
pub fn printTree(&self) {
let mut columns = HashSet::new();
columns.insert(0);
self.visualizeTree(0, true, &mut columns);
}
}
Çıktı şu şekildedir:
┌── 17
│ │ ┌── 3
│ │ │ └── 9
│ └── 2
│ └── 1
20
│ ┌── 7
│ │ │ ┌── 16
│ │ └── 15
└── 8
│ ┌── 11
└── 4
└── 13
Konsolda Yazdır:
500
700 300
200 400
Basit kod:
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<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 + 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("%s", " ");
firstNodeGap--;
}
levelFirstNode =false;
}
else
{
while(internalNodeGap>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;
}
}
İşte çok yönlü bir ağaç yazıcısı. En iyi görünümlü değil, ama birçok durumda hallediyor. Bunu anlayabilirseniz eğik çizgi eklemekten çekinmeyin.
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 sınıfı
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 sınıfı
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);
}
}
Ve son olarak, Düğüm Arayüzü
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public interface PrintableNode {
PrintableNodeInfo _getPrintableNodeInfo();
PrintableNode _getLeftChild();
PrintableNode _getRightChild();
}
Vasya Novikov'un cevabından uyarlanan ve ikili ağaçlar için uzmanlaşmış bir Scala çözümü:
/** 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)
}
}
Bu cevaplara da bakınız .
Özellikle abego TreeLayout'u kullanmak çok zor değildi , aşağıda varsayılan ayarlarla gösterilen sonuçları üretmek .
Bu aracı denerseniz bu uyarıyı not edin: Çocukları eklendikleri sırayla yazdırır. Sol ve sağ konular arasında bir BST için bu kütüphaneyi modifikasyon olmadan uygunsuz buldum.
Ayrıca, çocuk ekleme yöntemi sadece parent
vechild
parametre olarak düğümü . (Bu nedenle, bir grup düğümü işlemek için, bir kök oluşturmak için ilk düğümü ayrı ayrı almanız gerekir.)
Yukarıda bu çözümü kullanarak , sola ve sağa (çocuklara) <Node>
erişebilecek şekilde tür değiştirecek şekilde değiştirdim Node
.
Ağacınızı görselleştirmenin başka bir yolu: düğümleri bir xml dosyası olarak kaydedin ve ardından tarayıcınızın size hiyerarşiyi göstermesine izin verin:
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){
}
}
}
İşte test etmek için kod:
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();
Ve çıktı şöyle görünür:
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+"");
}
l++;
printNodeWithLvl( node.left,l,m);
printNodeWithLvl(node.right,l,m);
}
}
Bu ben uygulayabilirsiniz en basit sürümü biridir. umarım sana yardımcı olur
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def add(self, data):
if data < self.data:
if self.left is None:
self.left = Node(data)
else:
self.left.add(data)
if data > self.data:
if self.right is None:
self.right = Node(data)
else:
self.right.add(data)
def display(self):
diff = 16
start = 50
c = ' '
this_level = [(self, start)]
while this_level:
next_level = list()
last_line = ''
for node, d in this_level:
line = last_line + c*(d - len(last_line)) + str(node.data)
print(line, end='\r')
last_line = line
if node.left:
next_level.append((node.left, d - diff))
if node.right:
next_level.append((node.right, d + diff))
this_level = next_level
diff = max(diff//2, 2)
print('\n')
if __name__ == '__main__':
from random import randint, choice
values = [randint(0, 100) for _ in range(10)]
bst = Node(choice(values))
for data in values:
bst.add(data)
bst.display()