আমি জাভাতে কীভাবে বাইনারি গাছ মুদ্রণ করতে পারি যাতে আউটপুটটি এমন হয়:
4
/ \
2 5
আমার নোড:
public class Node<A extends Comparable> {
Node<A> left, right;
A data;
public Node(A data){
this.data = data;
}
}
আমি জাভাতে কীভাবে বাইনারি গাছ মুদ্রণ করতে পারি যাতে আউটপুটটি এমন হয়:
4
/ \
2 5
আমার নোড:
public class Node<A extends Comparable> {
Node<A> left, right;
A data;
public Node(A data){
this.data = data;
}
}
উত্তর:
আমি সাধারণ বাইনারি ট্রি প্রিন্টার তৈরি করেছি। আপনি এটি হিসাবে এটি ব্যবহার এবং সংশোধন করতে পারেন, তবে তা যাইহোক অপ্টিমাইজ করা হয়নি। আমি মনে করি যে এখানে অনেক কিছুই উন্নতি করা যেতে পারে;)
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;
}
}
আউটপুট 1:
2
/ \
/ \
/ \
/ \
7 5
/ \ / \
/ \ / \
2 6 3 6
/ \ / \ / \ / \
5 8 4 5 8 4 5 8
আউটপুট 2:
2
/ \
/ \
/ \
/ \
7 5
/ \ \
/ \ \
2 6 9
/ \ /
5 8 4
লাইন দ্বারা একটি [বড়] গাছ মুদ্রণ করুন।
আউটপুট উদাহরণ:
z
├── c
│ ├── a
│ └── b
├── d
├── e
│ └── asdf
└── f
কোড:
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 + " ");
}
}
}
}
পিএস এই উত্তরটি ঠিক "বাইনারি" গাছগুলিতে ফোকাস করে না - পরিবর্তে, এটি সমস্ত ধরণের গাছ মুদ্রণ করে। সমাধান লিনাক্সে "ট্রি" কমান্ড দ্বারা অনুপ্রাণিত হয়।
children.get(children.size() - 1)
যদি শিশুদের জন্য হাশম্যাপ ব্যবহার করা হয় তবে আপনি কীভাবে পুনরায় লিখবেন ? আমি অন্য প্রতিটি অংশটি পরিবর্তিত করতে পেরেছি তবে এটি একটি।
HashMap<String, List<String>>
?
HashMap<String, Node>
। স্ট্রিংটি নোডের আইডি।
আমি এর জন্য একটি উন্নত অ্যালগরিদম তৈরি করেছি, যা বিভিন্ন আকারের সুন্দরভাবে নোডগুলি পরিচালনা করে। এটি লাইন ব্যবহার করে টপ-ডাউন মুদ্রণ করে।
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;
}
}
}
আপনার গাছের জন্য এটি ব্যবহার করতে, আপনার Node
শ্রেণি প্রয়োগ করতে দিনPrintableNode
।
উদাহরণ আউটপুট:
2952:0
┌───────────────────────┴───────────────────────┐
1249:-1 5866:0
┌───────────┴───────────┐ ┌───────────┴───────────┐
491:-1 1572:0 4786:1 6190:0
┌─────┘ └─────┐ ┌─────┴─────┐
339:0 5717:0 6061:0 6271:0
???????????
নোডগুলির মধ্যে লাইনগুলির পরিবর্তে পাই তবে কেবল কিছু ইউটিএফ 8 আনস স্টাফের সমস্যা হওয়া উচিত। যাইহোক, দুর্দান্ত জিনিস, আমি বলতে হবে। এটি ব্যবহার করা সত্যই সহজ বলে আমার পক্ষে সেরা উত্তর।
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 ? " | " : " "));
}
}
}
মুদ্রণ করবে:
/----- 20
| \----- 15
/----- 14
| \----- 13
/----- 12
| | /----- 11
| \----- 10
| \----- 9
8
| /----- 7
| /----- 6
| | \----- 5
\----- 4
| /----- 3
\----- 2
\----- 1
ইনপুট জন্য
8 4 12 2 6 10 14 1 3 5 7 9 11 13 20 15
এটি @ অনুরাগের উত্তর থেকে একটি বৈকল্পিক - অতিরিক্ত | গুলি দেখতে এটি আমাকে বগল করছে
থেকে অভিযোজিত Vasya novikov এর উত্তর এটি আরো করতে বাইনারি , এবং একটি ব্যবহার StringBuilder
দক্ষতা জন্য (concatenating String
বস্তু জাভা একসঙ্গে সাধারণত অদক্ষ যায়)।
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();
}
আউটপুট:
│ ┌── 7
│ ┌── 6
│ │ └── 5
└── 4
│ ┌── 3
└── 2
└── 1
└── 0
right != null
আমি সম্পাদনা করেছি এবং এটি পরীক্ষা করেছি, এটি ভাল কাজ করে।
michal.kreuzman সুন্দর একটা আমি বলতে হবে।
আমি নিজেই একটি প্রোগ্রাম তৈরি করতে অলস বোধ করছি এবং নেটটিতে কোড অনুসন্ধান করার সময় যখন আমি এটি পেয়েছি এটি সত্যিই আমাকে সাহায্য করেছে।
তবে আমি এটি দেখতে ভীত হই যে এটি কেবলমাত্র একক অঙ্কের জন্য কাজ করে যেমন আপনি একাধিক ডিজিট ব্যবহার করতে চলেছেন, যেহেতু আপনি ফাঁকা স্থান ব্যবহার করছেন এবং ট্যাবগুলি নয় কাঠামোটি ভুল জায়গায় স্থান পেতে চলেছে এবং প্রোগ্রামটি এর ব্যবহারটি আলগা করবে।
আমার পরবর্তী কোডগুলির জন্য আমার আরও কিছু বড় ইনপুট প্রয়োজন (কমপক্ষে 10 এরও বেশি) এটি আমার পক্ষে কাজ করে না, এবং নেট থেকে অনেক অনুসন্ধান করার পরে যখন আমি কিছু পাইনি, আমি নিজেই একটি প্রোগ্রাম তৈরি করেছিলাম।
এটি এখন কিছু বাগ আছে, এখনই আমি সেগুলি সংশোধন করতে অলস বোধ করছি তবে এটি খুব সুন্দরভাবে মুদ্রণ করে এবং নোডগুলি যে কোনও বড় মান নিতে পারে।
প্রশ্নটি যেমন উল্লেখ করেছে তেমন গাছ হতে যাচ্ছে না তবে এটি 270 ডিগ্রি ঘোরানো হয়েছে :)
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);
}
আপনার নিজস্ব নির্দিষ্ট ট্রিনোডের সাথে এই ফাংশনটি রাখুন এবং প্রথমদিকে স্তরটি 0 রাখুন এবং উপভোগ করুন!
এখানে কিছু নমুনা আউটপুট রয়েছে:
| | |-------11
| |-------10
| | |-------9
|-------8
| | |-------7
| |-------6
| | |-------5
4
| |-------3
|-------2
| |-------1
| | | |-------10
| | |-------9
| |-------8
| | |-------7
|-------6
| |-------5
4
| |-------3
|-------2
| |-------1
কেবল সমস্যাটি প্রসারিত শাখাগুলির সাথে; যত তাড়াতাড়ি সম্ভব সমস্যাটি সমাধান করার চেষ্টা করব তবে ততক্ষণ আপনি এটিও ব্যবহার করতে পারেন।
আপনার গাছের প্রতিটি স্তরের দ্বিগুণ দূরত্বের প্রয়োজন হবে:
একটি / / / / খ্রিস্টপূর্ব / \ / \ / \ / \ defg / \ / \ / \ / hijklmno
আপনি আপনার গাছকে অ্যারেতে সংরক্ষণ করতে পারবেন, প্রতিটি গভীরতার জন্য একটি অ্যারে:
[[একটি], [B, C], [D, E, F, G], [H, I, J, K, L, M, এন, হে]]
আপনার গাছটি পূর্ণ না হলে আপনাকে সেই অ্যারেতে খালি মানগুলি অন্তর্ভুক্ত করতে হবে:
একটি / / / / খ্রিস্টপূর্ব / \ / \ / \ / \ defg / \ / / \ hiklmo [[এ], [খ, সি], [ডি, ই, এফ, জি], [এইচ, আই,, কে, এল, এম, ও]]
তারপরে আপনি আপনার গাছটি মুদ্রণের জন্য অ্যারে জুড়ে পুনরুক্তি করতে পারবেন, প্রথম উপাদানটির আগে শূন্যস্থানগুলি গভীরতার উপর নির্ভর করে এবং পরবর্তী স্তরটির জন্য অ্যারেতে সংশ্লিষ্ট উপাদানগুলি পূরণ করা হয়েছে কিনা তা নির্ভর করে লাইনগুলি মুদ্রণ করতে পারে। যদি আপনার মানগুলি একাধিক চরিত্রের দীর্ঘ হতে পারে তবে অ্যারের উপস্থাপনা তৈরি করার সময় আপনাকে দীর্ঘতম সন্ধান করতে হবে এবং সেই অনুসারে সমস্ত প্রস্থ এবং রেখার সংখ্যাকে গুণ করতে হবে।
আমি একটি বড় সাধারণ গাছ মুদ্রণের জন্য ভাস্যনাভিকভের উত্তরটি খুব দরকারী বলে খুঁজে পেয়েছিলাম এবং এটি বাইনারি গাছের জন্য পরিবর্তন করেছি
কোড:
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);
}
}
}
নমুনা আউটপুট:
\-- 7
|-- 3
| |-- 1
| | \-- 2
| \-- 5
| |-- 4
| \-- 6
\-- 11
|-- 9
| |-- 8
| \-- 10
\-- 13
|-- 12
\-- 14
স্কাল ভাষার একটি সমাধান , যা আমি জাভাতে লিখেছি তার সাথে সাদৃশ্য :
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
}
}
আউটপুট উদাহরণ:
vasya
├── frosya
│ ├── petya
│ │ └── masha
│ └── kolya
└── frosya2
আমি জানি আপনার ছেলেরা সবার দুর্দান্ত সমাধান আছে; আমি কেবল আমার ভাগ করে নিতে চাই - সম্ভবত এটি সবচেয়ে ভাল উপায় নয়, তবে এটি আমার পক্ষে নিখুঁত!
python
এবং সহ pip
, এটি সত্যিই বেশ সহজ! গম্ভীর গর্জন!
ম্যাক বা উবুন্টুতে (আমার ম্যাক হয়)
$ pip install drawtree
$python
, পাইথন কনসোলে প্রবেশ করুন; আপনি এটি অন্য উপায়ে করতে পারেনfrom drawtree import draw_level_order
draw_level_order('{2,1,3,0,7,9,1,2,#,1,0,#,#,8,8,#,#,#,#,7}')
সম্পন্ন!
2
/ \
/ \
/ \
1 3
/ \ / \
0 7 9 1
/ / \ / \
2 1 0 8 8
/
7
উৎস খোজা:
আমি এই পোস্টটি দেখার আগে, আমি গুগল "বাইনারি গাছের সরল পাঠ্য"
এবং আমি এই https://www.reddit.com/r/learnpython/comments/3naiq8/draw_binary_tree_in_plain_text/ খুঁজে পেয়েছি , আমাকে এই https://github.com/msbanik/drawtree এ ডাইরেক্ট করুন
java
কোনও জাভা উত্তরটি প্রত্যাশা করে প্রশ্নটি ট্যাগ করবে :)
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
এটি একটি গাছ মুদ্রণের জন্য খুব সহজ সমাধান। এটি তেমন সুন্দর নয়, তবে এটি সত্যই সহজ:
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);
}
নমুনা আউটপুট:
106 105 104 103 102 101 100
ভাস্যনাভিকভ উত্তরের ভিত্তিতে। কিছু জাভা যাদু দ্বারা উন্নত: জেনেরিকস এবং ফাংশনাল ইন্টারফেস।
/**
* 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);
}
}
প্রাথমিক কল উদাহরণ:
Function<ChecksumModel, List<ChecksumModel>> getChildrenFunc = node -> getChildrenOf(node)
printTreeRec("", rootNode, getChildrenFunc, true);
কিছু আউটপুট হবে
└── rootNode
├── childNode1
├── childNode2
│ ├── childNode2.1
│ ├── childNode2.2
│ └── childNode2.3
├── childNode3
└── childNode4
আমি জাভাতে একটি বাইনারি ট্রি প্রিন্টার লিখেছি।
কোডটি এখানে গিটহাবে রয়েছে ।
এটি রান সময় দক্ষতার জন্য অনুকূলিত করা হয়নি, তবে যেহেতু আমরা ASCII তে মুদ্রণের কথা বলছি, আমি বুঝতে পেরেছিলাম এটি খুব বড় গাছগুলিতে ব্যবহার করা হচ্ছে না। যদিও এতে কিছু সুন্দর বৈশিষ্ট্য রয়েছে।
কিছু ডেমো / পরীক্ষার প্রোগ্রাম অন্তর্ভুক্ত করা হয়।
প্রোগ্রাম দ্বারা মুদ্রিত হিসাবে একটি এলোমেলোভাবে উত্পাদিত বাইনারি গাছের একটি উদাহরণ অনুসরণ করে। এটি একটি ছোট বাম সাবট্রির নীচে বিস্তৃত একটি বৃহত ডান সাবট্রির সাথে স্থানের দক্ষ ব্যবহারের চিত্রণ করে:
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
পৃষ্ঠাতে পাঁচটি নোড বাইনারি গাছ (অর্ডার লেবেল সহ) মুদ্রণের উদাহরণ:
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
নীচে 4 টি বিভিন্ন উপায়ে 1 এবং 3 এর অনুভূমিক ব্যবধান সহ এবং তির্যক এবং অনুভূমিক শাখা সহ একই গাছের মুদ্রিত নীচের উদাহরণ is
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
একটি মন্তব্য দিয়ে এখানে আমাকে পিং করুন p
এটি একটি আকর্ষণীয় প্রশ্ন এবং আমি এটির জন্য একটি প্রকল্পও লিখেছি।
এখানে কিছু উদাহরন:
র্যান্ডম বিএসটি প্রিন্ট করুন।
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
লেটকোড-স্টাইল স্তরের অর্ডার অ্যারে থেকে ট্রি প্রিন্ট করুন, '#' এর অর্থ একটি পাথ টার্মিনেটর যেখানে নীচে কোনও নোড নেই।
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
আমার একটি প্রকল্পে আমার বাইনারি গাছের মুদ্রণ করা দরকার, এর জন্য আমি একটি জাভা ক্লাস প্রস্তুত করেছি TreePrinter
, নমুনা আউটপুটগুলির মধ্যে একটি:
[+]
/ \
/ \
/ \
/ \
/ \
[*] \
/ \ [-]
[speed] [2] / \
[45] [12]
ক্লাসের TreePrinter
সাথে ক্লাসের জন্য এখানে কোড দেওয়া আছে TextNode
। যে কোনও গাছের মুদ্রণের জন্য আপনি TextNode
ক্লাস সহ একটি সমতুল গাছ তৈরি করতে পারেন ।
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;
}
}
অবশেষে প্রদত্ত নমুনা মুদ্রণের জন্য এখানে একটি পরীক্ষার শ্রেণি রয়েছে:
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));
}
}
এটি খুব সহজেই ভিজ্যুয়ালাইজ করতে আপনি একটি অ্যাপলেট ব্যবহার করতে পারেন। আপনাকে নিম্নলিখিত আইটেমগুলি মুদ্রণ করতে হবে।
কিছু দৃশ্যমান ব্যাসার্ধের সাথে নোডগুলি বৃত্ত হিসাবে মুদ্রণ করুন
প্রতিটি নোডের জন্য স্থানাঙ্কগুলি পান।
এক্স কোঅর্ডিনেটটি নোডের অভ্যন্তরীণ ট্র্যাভার্সালটিতে দেখার পূর্বে নোডের পরিদর্শন করা হিসাবে এটি ভিজ্যুয়ালাইজ করা যেতে পারে।
Y স্থানাঙ্কটি নির্দিষ্ট নোডের গভীরতা হিসাবে ভিজ্যুয়ালাইজ করা যায়।
পিতা-মাতা এবং বাচ্চাদের মধ্যে লাইনগুলি মুদ্রণ করুন
নোডের এক্স এবং ওয়াই স্থানাঙ্ক এবং পৃথক তালিকায় প্রতিটি নোডের পিতামাতার বজায় রেখে এটি করা যেতে পারে।
রুট ব্যতীত প্রতিটি নোডের জন্য শিশু এবং পিতামাতার উভয়ের x এবং y স্থানাঙ্ক গ্রহণ করে তার পিতামাতার সাথে প্রতিটি নোডে যোগদান করুন।
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
শুধুমাত্র 1 থেকে 2 ডিজিটের পূর্ণসংখ্যার জন্য কাজ করে (আমি এটিকে জেনেরিক করতে অলস ছিলাম)
অনুভূমিক দেখার জন্য এটি ছিল সহজ সমাধান। গুচ্ছ উদাহরণ দিয়ে চেষ্টা করা। আমার উদ্দেশ্য জন্য ভাল কাজ করে। @ নিতিন-কে এর উত্তর থেকে আপডেট হয়েছে।
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);
}
}
কল করুন:
bst.print("", bst.root, false);
সমাধান:
|-- 80
|-- 70
|-- 60
|-- 50
|-- 40
|-- 30
|-- 20
|-- 10
node_length * nodes_count + space_length * spaces_count*
।গিটহাবের কোড: ইউসেফআরাফাতনাস্রি / বিএসটি-এসকিআই-ভিজ্যুয়ালাইজেশন
07
/\
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
03 11
/\ /\
/ \ / \
/ \ / \
/ \ / \
/ \ / \
01 05 09 13
/\ /\ /\ /\
/ \ / \ / \ / \
00 02 04 06 08 10 12 14
visualize
ফাংশন নয়, এটি পুরো visualizer
ক্লাস যা শিরোনাম ফাইল সহ প্রায় 200 লোক রয়েছে।
যারা মরিচা সমাধান খুঁজছেন তাদের জন্য:
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);
}
}
আউটপুটটি এরকম কিছু:
┌── 17
│ │ ┌── 3
│ │ │ └── 9
│ └── 2
│ └── 1
20
│ ┌── 7
│ │ │ ┌── 16
│ │ └── 15
└── 8
│ ┌── 11
└── 4
└── 13
কনসোলে মুদ্রণ করুন:
500
700 300
200 400
সাধারণ কোড:
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;
}
}
এখানে একটি খুব বহুমুখী ট্রি প্রিন্টার রয়েছে। সেরা দেখাচ্ছে না, তবে এটি অনেকগুলি কেস পরিচালনা করে। যদি আপনি এটি বের করতে পারেন তবে স্ল্যাশগুলি নির্দ্বিধায় যোগ করুন।
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;
}
}
নোডইনফো ক্লাস
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();
}
}
নোডপজিশন ক্লাস
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public class PrintableNodePosition implements Comparable<PrintableNodePosition> {
public final int row;
public final int column;
public final PrintableNodeInfo nodeInfo;
public PrintableNodePosition(PrintableNodeInfo nodeInfo, int row, int column){
this.row = row;
this.column = column;
this.nodeInfo = nodeInfo;
}
@Override
public int compareTo(PrintableNodePosition o) {
return Integer.compare(this.column,o.column);
}
}
এবং, অবশেষে নোড ইন্টারফেস
package com.tomac120.NodePrinter;
/**
* Created by elijah on 6/28/16.
*/
public interface PrintableNode {
PrintableNodeInfo _getPrintableNodeInfo();
PrintableNode _getLeftChild();
PrintableNode _getRightChild();
}
ভ্যাস্যা নোভিকভের উত্তর থেকে অভিযোজিত এবং বাইনারি গাছগুলির জন্য বিশেষত একটি স্কালা সমাধান:
/** 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)
}
}
আরও দেখুন এই উত্তরগুলোর ।
বিশেষত ডিফল্ট সেটিংসের সাথে নীচে দেখানো ফলাফল উত্পাদন করতে অ্যাবেগো ট্রিলআউট ব্যবহার করা খুব কঠিন ছিল না ।
যদি আপনি সেই সরঞ্জামটি চেষ্টা করে থাকেন তবে এই সাবধানবাণীটি নোট করুন: এটি বাচ্চাদের যুক্ত করার ক্রমে মুদ্রণ করে। একটি বিএসটি যেখানে বাম বনাম ডান বিষয়গুলির জন্য আমি এই লাইব্রেরিটি সংশোধন ছাড়াই অনুপযুক্ত বলে মনে করেছি।
এছাড়াও, বাচ্চাদের যুক্ত করার পদ্ধতিটি পরামিতি হিসাবে কেবল একটি parent
এবং child
নোড নেয় । (সুতরাং একগুচ্ছ নোডগুলি প্রক্রিয়া করতে, আপনাকে অবশ্যই একটি শিকড় তৈরি করতে প্রথমে আলাদাভাবে নিতে হবে))
আমি উপরের এই সমাধানটি ব্যবহার করে শেষ করেছি , এটিকে সংশোধন করে টাইপটি নিতে <Node>
যাতে Node
বাম এবং ডান (শিশুদের) অ্যাক্সেস পেতে পারে ।
আপনার গাছটি দেখার জন্য এখানে আরও একটি উপায় রয়েছে: এক্সএমএল ফাইল হিসাবে নোডগুলি সংরক্ষণ করুন এবং তারপরে আপনার ব্রাউজারটি আপনাকে শ্রেণিবিন্যাস দেখায়:
class treeNode{
int key;
treeNode left;
treeNode right;
public treeNode(int key){
this.key = key;
left = right = null;
}
public void printNode(StringBuilder output, String dir){
output.append("<node key='" + key + "' dir='" + dir + "'>");
if(left != null)
left.printNode(output, "l");
if(right != null)
right.printNode(output, "r");
output.append("</node>");
}
}
class tree{
private treeNode treeRoot;
public tree(int key){
treeRoot = new treeNode(key);
}
public void insert(int key){
insert(treeRoot, key);
}
private treeNode insert(treeNode root, int key){
if(root == null){
treeNode child = new treeNode(key);
return child;
}
if(key < root.key)
root.left = insert(root.left, key);
else if(key > root.key)
root.right = insert(root.right, key);
return root;
}
public void saveTreeAsXml(){
StringBuilder strOutput = new StringBuilder();
strOutput.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
treeRoot.printNode(strOutput, "root");
try {
PrintWriter writer = new PrintWriter("C:/tree.xml", "UTF-8");
writer.write(strOutput.toString());
writer.close();
}
catch (FileNotFoundException e){
}
catch(UnsupportedEncodingException e){
}
}
}
এটি পরীক্ষা করার কোড এখানে:
tree t = new tree(1);
t.insert(10);
t.insert(5);
t.insert(4);
t.insert(20);
t.insert(40);
t.insert(30);
t.insert(80);
t.insert(60);
t.insert(50);
t.saveTreeAsXml();
এবং আউটপুট এই মত দেখাচ্ছে:
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);
}
}
এটি আমি প্রয়োগ করতে পারি এমন একটি সহজতম সংস্করণ। আমি এটি আপনাকে সাহায্য করে আশা করি
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()