বাইনারি ট্রি ডায়াগ্রাম কীভাবে প্রিন্ট করবেন?


163

আমি জাভাতে কীভাবে বাইনারি গাছ মুদ্রণ করতে পারি যাতে আউটপুটটি এমন হয়:

   4 
  / \ 
 2   5 

আমার নোড:

public class Node<A extends Comparable> {
    Node<A> left, right;
    A data;

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

5
এটা একটা মুশকিল। আমি মনে করি আপনাকে প্রথমে গাছের গভীরতা নির্ধারণ করতে হবে। ব্যক্তিগতভাবে, আমি গ্রাডভিজে কেবল নোডের গ্রাফটি ফেলে দিয়েছি এবং এটির সাথে এটি মোকাবেলা করতে দেব। :-)
সর্বময়

দেখে মনে হচ্ছে আপনার যদি অনেকগুলি উপাদান থাকে তবে মূল উপাদানটির থেকে এটির একটি বিশাল প্রান্ত আসবে।

আমার গাছে একটি getDept () পদ্ধতি আছে
টিয়ান

1
ধারণাটি আমাকে আনন্দিত করার কারণে, আমি কোডটি সি ++ তে লিখেছিলাম এবং এটি গ্রাফভিজ ডিজিট্রাফ ফর্ম্যাটটিকে ছিটকে ফেলেছিলাম। সুন্দর ফর্ম্যাট গাছ।
সর্বশক্তিমান

উত্তর:


238

আমি সাধারণ বাইনারি ট্রি প্রিন্টার তৈরি করেছি। আপনি এটি হিসাবে এটি ব্যবহার এবং সংশোধন করতে পারেন, তবে তা যাইহোক অপ্টিমাইজ করা হয়নি। আমি মনে করি যে এখানে অনেক কিছুই উন্নতি করা যেতে পারে;)

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   

1
এই আউটপুট অনুভূমিক রূপান্তর কিভাবে?
জিগেশ আজ ২

অনুভূমিক আউটপুট জন্য Vasya Novikov এর সমাধান ব্যবহার করা ভাল।
michal.kreuzman

3
এটি দুর্দান্ত হবে যদি আপনি 2 ^ n - 1 কে প্রথম স্পেস হিসাবে এবং 2 ^ (n + 1) - 1 টি ফাঁকা জায়গাগুলির মধ্যে বেছে নেওয়ার বিষয়ে বিস্তারিত বলতে পারেন
ডিজে '

এটি ভারসাম্যযুক্ত গাছের পক্ষে ভাল কারণ আমি 15 টি মানের ডান স্কিউ গাছগুলির জন্য এটি চেষ্টা করেছি এবং এটি মুদ্রণটি দেখতে খুব নিয়ন্ত্রণহীন হয়ে পড়ে।
akhil_mittal

3
আমার গাছটি 44 স্তর গভীর, তাই 8796093022207 হোয়াইটস্পেসগুলি মুদ্রণের চেষ্টা করার সময় জাভা ক্র্যাশ হয়ে যায়। সুতরাং সতর্ক করা উচিত।
সিএক্স গেমার

286

লাইন দ্বারা একটি [বড়] গাছ মুদ্রণ করুন।

আউটপুট উদাহরণ:

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>। স্ট্রিংটি নোডের আইডি।
লে এনগুইন ডুই আনহ

আমি আসলে টেক্সট-ট্রি নামে একটি ছোট জাভা লাইব্রেরিতে অনুরূপ কিছু বাস্তবায়ন করেছি । হতে পারে এটি কাউকে সাহায্য করে।
বারফুইন

47

আমি এর জন্য একটি উন্নত অ্যালগরিদম তৈরি করেছি, যা বিভিন্ন আকারের সুন্দরভাবে নোডগুলি পরিচালনা করে। এটি লাইন ব্যবহার করে টপ-ডাউন মুদ্রণ করে।

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   

আমি "নির্বাচিত উত্তর" কৌশলটি প্রতিলিপি করার চেষ্টা করছিলাম। তবে আমি মনে করি এটি এখানে সেরা উত্তর। তাই দৃust় এবং সংক্ষিপ্ত।
বিকান্ত গোয়েল

এটি বাস্তবায়নের পরে এটি দুর্দান্ত কাজ করে বলে মনে হয় তবে কেবলমাত্র ভারসাম্যযুক্ত গাছের জন্য। ভারসাম্যহীন যে কোনও কিছুই বিজোড় ফলাফল দেয়।
mitbanip

আমি ???????????নোডগুলির মধ্যে লাইনগুলির পরিবর্তে পাই তবে কেবল কিছু ইউটিএফ 8 আনস স্টাফের সমস্যা হওয়া উচিত। যাইহোক, দুর্দান্ত জিনিস, আমি বলতে হবে। এটি ব্যবহার করা সত্যই সহজ বলে আমার পক্ষে সেরা উত্তর।
ফিটজ

হ্যাঁ, এটা ছিল। আপনার লাইন এবং স্পেস স্পেসের সমস্ত বিশেষ অক্ষরকে কেবল পরিবর্তন করতে হয়েছিল ।
ফিটজ

নাইস, উপাদানের একটি অ্যারের মুদ্রণ সমর্থন করার জন্য, একটি নির্মিত সারকথা যা শুধু যে গাছ মুদ্রণের জন্য @MightyPork যুক্তিবিজ্ঞান ব্যবহার করে। দেখুনpublic static <T> void print(T[] elems)
নিও

40
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

এটি @ অনুরাগের উত্তর থেকে একটি বৈকল্পিক - অতিরিক্ত | গুলি দেখতে এটি আমাকে বগল করছে


আপনি যদি এটি 90 rot ঘোরাতে পারতেন তবে দুর্দান্ত লাগবে °
অভিজিৎ সরকার

34

থেকে অভিযোজিত 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

যখন আমরা একটি বিএসটিতে 30,40,50,60,70,80 মান সন্নিবেশ করি তখন এটি কোনও গাছের পক্ষে কাজ করে না। যেহেতু ডান স্কিচ গাছ তৈরি করে। IsTail এর মানটি মিথ্যা হওয়া উচিত যখন right != nullআমি সম্পাদনা করেছি এবং এটি পরীক্ষা করেছি, এটি ভাল কাজ করে।
akhil_mittal

ইনপুটটির জন্য ধন্যবাদ, আমি কেবল উত্তরটি সম্পাদনা করেছি, এটি আরও ভাল?
টড ডেভিস

আপনাকে ধন্যবাদ, @ ভাস্য নোভিকভের উত্তর দুর্দান্ত তবে আমার এটির একটি লিঙ্কলিস্ট সংস্করণ দরকার, এবং আপনার উত্তরটি আমার ক্ষেত্রে উপযুক্ত।
হাইচউ

সমস্ত উত্তরে, এটি সর্বোত্তম দেখাচ্ছে গাছটি উত্পাদন করে এবং কোডটি খুব পরিষ্কার!
পি-রোদ

15

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

কেবল সমস্যাটি প্রসারিত শাখাগুলির সাথে; যত তাড়াতাড়ি সম্ভব সমস্যাটি সমাধান করার চেষ্টা করব তবে ততক্ষণ আপনি এটিও ব্যবহার করতে পারেন।


14

আপনার গাছের প্রতিটি স্তরের দ্বিগুণ দূরত্বের প্রয়োজন হবে:

       একটি
      /
     /
    /
   /
   খ্রিস্টপূর্ব
  / \ / \
 / \ / \
 defg
/ \ / \ / \ /
hijklmno

আপনি আপনার গাছকে অ্যারেতে সংরক্ষণ করতে পারবেন, প্রতিটি গভীরতার জন্য একটি অ্যারে:

[[একটি], [B, C], [D, E, F, G], [H, I, J, K, L, M, এন, হে]]

আপনার গাছটি পূর্ণ না হলে আপনাকে সেই অ্যারেতে খালি মানগুলি অন্তর্ভুক্ত করতে হবে:

       একটি
      /
     /
    /
   /
   খ্রিস্টপূর্ব
  / \ / \
 / \ / \
 defg
/ \ / / \
hiklmo
[[এ], [খ, সি], [ডি, ই, এফ, জি], [এইচ, আই,, কে, এল, এম, ও]]

তারপরে আপনি আপনার গাছটি মুদ্রণের জন্য অ্যারে জুড়ে পুনরুক্তি করতে পারবেন, প্রথম উপাদানটির আগে শূন্যস্থানগুলি গভীরতার উপর নির্ভর করে এবং পরবর্তী স্তরটির জন্য অ্যারেতে সংশ্লিষ্ট উপাদানগুলি পূরণ করা হয়েছে কিনা তা নির্ভর করে লাইনগুলি মুদ্রণ করতে পারে। যদি আপনার মানগুলি একাধিক চরিত্রের দীর্ঘ হতে পারে তবে অ্যারের উপস্থাপনা তৈরি করার সময় আপনাকে দীর্ঘতম সন্ধান করতে হবে এবং সেই অনুসারে সমস্ত প্রস্থ এবং রেখার সংখ্যাকে গুণ করতে হবে।


গাছটি সম্পূর্ণ না হলে কী হবে? সেক্ষেত্রে মনে হচ্ছে আপনার প্রতিটি স্তরে স্থান দ্বিগুণ না করে এটি করতে সক্ষম হওয়া উচিত।
টেম্পলেটটিফাইফ

হ্যাঁ, তবে কেবলমাত্র খুব সীমিত ক্ষেত্রে যেখানে বেশিরভাগ সাবট্রিগুলি নীচের দিকে একই স্তরের গাছের পরিবর্তে তালিকার সাথে সংযুক্ত থাকে বা আপনি স্তরগুলির মধ্যে বিভিন্ন ফাঁক দিয়ে বিভিন্ন
সাবট্রি আঁকেন

13

আমি একটি বড় সাধারণ গাছ মুদ্রণের জন্য ভাস্যনাভিকভের উত্তরটি খুব দরকারী বলে খুঁজে পেয়েছিলাম এবং এটি বাইনারি গাছের জন্য পরিবর্তন করেছি

কোড:

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

8

স্কাল ভাষার একটি সমাধান , যা আমি জাভাতে লিখেছি তার সাথে সাদৃশ্য :

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

1
জাভাতেও লাম্বদা পাওয়া গেলে সম্ভবত আপনি নিজের জাভা সমাধানটি আপডেট করতে চান?
টিনটিন

@ টিনটিন স্কেলা কেবল ল্যাম্বদা ফাংশন সম্পর্কে নয়। কিন্তু আপনি যদি মনে জাভা একটি ভাল উন্নতি আছে, "সম্পাদনা" বিনা দ্বিধায়, যা Stackoverflow সম্প্রদায় দ্বারা গ্রহণ করা হবে যদি বলিয়া গণ্য উপকারী .;)
VasiliNovikov

5

আমি জানি আপনার ছেলেরা সবার দুর্দান্ত সমাধান আছে; আমি কেবল আমার ভাগ করে নিতে চাই - সম্ভবত এটি সবচেয়ে ভাল উপায় নয়, তবে এটি আমার পক্ষে নিখুঁত!

pythonএবং সহ pip, এটি সত্যিই বেশ সহজ! গম্ভীর গর্জন!

ম্যাক বা উবুন্টুতে (আমার ম্যাক হয়)

  1. ওপেন টার্মিনাল
  2. $ pip install drawtree
  3. $python, পাইথন কনসোলে প্রবেশ করুন; আপনি এটি অন্য উপায়ে করতে পারেন
  4. from drawtree import draw_level_order
  5. 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 এ ডাইরেক্ট করুন


@ ডেনিসিভিতালি ওহ হ্যাঁ আপনি ঠিক বলেছেন: আমার সম্ভবত এটি 'সিরিয়ালযুক্ত স্তরের অর্ডার ট্র্যাভারসাল (যে কোনও ভাষা / পাইথন) থেকে গাছ মুদ্রণ করতে হবে "এ নিয়ে যাওয়া উচিত।
শন এল

3
আমি অভদ্র দেখতে চাইনি, তবে যখন javaকোনও জাভা উত্তরটি প্রত্যাশা করে প্রশ্নটি ট্যাগ করবে :)
ড্যানিস ভিটালি

3
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   

2

এটি একটি গাছ মুদ্রণের জন্য খুব সহজ সমাধান। এটি তেমন সুন্দর নয়, তবে এটি সত্যই সহজ:

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

2

ভাস্যনাভিকভ উত্তরের ভিত্তিতে। কিছু জাভা যাদু দ্বারা উন্নত: জেনেরিকস এবং ফাংশনাল ইন্টারফেস।

/**
 * 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

2

আমি জাভাতে একটি বাইনারি ট্রি প্রিন্টার লিখেছি।

কোডটি এখানে গিটহাবে রয়েছে

এটি রান সময় দক্ষতার জন্য অনুকূলিত করা হয়নি, তবে যেহেতু আমরা ASCII তে মুদ্রণের কথা বলছি, আমি বুঝতে পেরেছিলাম এটি খুব বড় গাছগুলিতে ব্যবহার করা হচ্ছে না। যদিও এতে কিছু সুন্দর বৈশিষ্ট্য রয়েছে।

  1. এটি জায়গার দক্ষ ব্যবহার করে যাতে একটি বৃহত্তর সাবট্রি যতটা সম্ভব ছোট্ট একটিের অধীনে প্রসারিত হয়।
  2. নোড লেবেলের মধ্যে ন্যূনতম অনুভূমিক স্থান নির্ধারণের জন্য একটি প্যারামিটার রয়েছে।
  3. নোড লেবেলগুলি নির্বিচারে দৈর্ঘ্যের স্ট্রিং।
  4. একটি একক গাছ মুদ্রণের জন্য একটি পদ্ধতি ছাড়াও, প্রয়োজনীয় যতগুলি সারি ব্যবহার করে পৃষ্ঠা জুড়ে (পৃষ্ঠার প্রস্থের জন্য একটি প্যারামিটার সহ) আনুভূমিকভাবে গাছের তালিকা প্রিন্ট করার একটি পদ্ধতি রয়েছে।
  5. তির্যক শাখা (স্ল্যাশ এবং ব্যাকস্ল্যাশ অক্ষর ব্যবহার করে) বা অনুভূমিক শাখা (এসকিআই বাক্স অঙ্কন অক্ষর ব্যবহার করে) গাছ মুদ্রণ করার একটি বিকল্প রয়েছে। পরবর্তীটি আরও কমপ্যাক্ট এবং গাছের স্তর আরও চাক্ষুষভাবে পরিষ্কার করে তোলে।
  6. এটা কাজ করে।

কিছু ডেমো / পরীক্ষার প্রোগ্রাম অন্তর্ভুক্ত করা হয়।

প্রোগ্রাম দ্বারা মুদ্রিত হিসাবে একটি এলোমেলোভাবে উত্পাদিত বাইনারি গাছের একটি উদাহরণ অনুসরণ করে। এটি একটি ছোট বাম সাবট্রির নীচে বিস্তৃত একটি বৃহত ডান সাবট্রির সাথে স্থানের দক্ষ ব্যবহারের চিত্রণ করে:

             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
মাকেন

2

এটি একটি আকর্ষণীয় প্রশ্ন এবং আমি এটির জন্য একটি প্রকল্পও লিখেছি।

বাইনারি-ট্রি-প্রিন্টার

এখানে কিছু উদাহরন:

র্যান্ডম বিএসটি প্রিন্ট করুন।

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

1

আমার একটি প্রকল্পে আমার বাইনারি গাছের মুদ্রণ করা দরকার, এর জন্য আমি একটি জাভা ক্লাস প্রস্তুত করেছি 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));
    }
}

1

এটি খুব সহজেই ভিজ্যুয়ালাইজ করতে আপনি একটি অ্যাপলেট ব্যবহার করতে পারেন। আপনাকে নিম্নলিখিত আইটেমগুলি মুদ্রণ করতে হবে।

  1. কিছু দৃশ্যমান ব্যাসার্ধের সাথে নোডগুলি বৃত্ত হিসাবে মুদ্রণ করুন

    • প্রতিটি নোডের জন্য স্থানাঙ্কগুলি পান।

    • এক্স কোঅর্ডিনেটটি নোডের অভ্যন্তরীণ ট্র্যাভার্সালটিতে দেখার পূর্বে নোডের পরিদর্শন করা হিসাবে এটি ভিজ্যুয়ালাইজ করা যেতে পারে।

    • Y স্থানাঙ্কটি নির্দিষ্ট নোডের গভীরতা হিসাবে ভিজ্যুয়ালাইজ করা যায়।


  1. পিতা-মাতা এবং বাচ্চাদের মধ্যে লাইনগুলি মুদ্রণ করুন

    • নোডের এক্স এবং ওয়াই স্থানাঙ্ক এবং পৃথক তালিকায় প্রতিটি নোডের পিতামাতার বজায় রেখে এটি করা যেতে পারে।

    • রুট ব্যতীত প্রতিটি নোডের জন্য শিশু এবং পিতামাতার উভয়ের x এবং y স্থানাঙ্ক গ্রহণ করে তার পিতামাতার সাথে প্রতিটি নোডে যোগদান করুন।


আপনি কি দয়া করে ভিজ্যুয়ালাইজ করতে পারেন এবং বিদ্যমান উত্তরের চেয়ে ভাল সমাধান দিতে পারেন?
এনামুল হাসান

1
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 ডিজিটের পূর্ণসংখ্যার জন্য কাজ করে (আমি এটিকে জেনেরিক করতে অলস ছিলাম)

স্কিউ সম্পূর্ণ


1

অনুভূমিক দেখার জন্য এটি ছিল সহজ সমাধান। গুচ্ছ উদাহরণ দিয়ে চেষ্টা করা। আমার উদ্দেশ্য জন্য ভাল কাজ করে। @ নিতিন-কে এর উত্তর থেকে আপডেট হয়েছে।

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

1
  1. আপনার গাছটিকে আপনার ক্রসকে অতিক্রম করতে হবে level
  2. নোড দৈর্ঘ্য এবং স্থান দৈর্ঘ্য চয়ন করুন ।
  3. গাছ পেতে প্রস্থ বেস প্রতিটি আপেক্ষিক স্তর যা node_length * nodes_count + space_length * spaces_count*
  4. ব্রাঞ্চিং, স্পেসিং, ইনডেন্টেশন এবং গণনা করা বেস প্রস্থের মধ্যে একটি সম্পর্ক সন্ধান করুন।

গিটহাবের কোড: ইউসেফআরাফাতনাস্রি / বিএসটি-এসকিআই-ভিজ্যুয়ালাইজেশন

                                             07                     
                                             /\                     
                                            /  \                    
                                           /    \                   
                                          /      \                  
                                         /        \                 
                                        /          \                
                                       /            \               
                                      /              \              
                                     /                \             
                                    /                  \            
                                   /                    \           
                                 03                      11         
                                 /\                      /\         
                                /  \                    /  \        
                               /    \                  /    \       
                              /      \                /      \      
                             /        \              /        \     
                           01          05          09          13   
                           /\          /\          /\          /\   
                          /  \        /  \        /  \        /  \  
                        00    02    04    06    08    10    12    14

আমি বলব কোডটি যথেষ্ট সংক্ষিপ্ত যে আপনি এটি আপনার উত্তরে এম্বেড করতে পারেন।
m02ph3u5

কোডটি কেবল visualizeফাংশন নয়, এটি পুরো visualizerক্লাস যা শিরোনাম ফাইল সহ প্রায় 200 লোক রয়েছে।
ইউসুফরাফাতনাস্রি

1

যারা মরিচা সমাধান খুঁজছেন তাদের জন্য:

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

0

কনসোলে মুদ্রণ করুন:

                                                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;
        }

    }

0

এখানে একটি খুব বহুমুখী ট্রি প্রিন্টার রয়েছে। সেরা দেখাচ্ছে না, তবে এটি অনেকগুলি কেস পরিচালনা করে। যদি আপনি এটি বের করতে পারেন তবে স্ল্যাশগুলি নির্দ্বিধায় যোগ করুন। এখানে চিত্র বর্ণনা লিখুন

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();
}

0

ভ্যাস্যা নোভিকভের উত্তর থেকে অভিযোজিত এবং বাইনারি গাছগুলির জন্য বিশেষত একটি স্কালা সমাধান:

/** 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)
  }
}

: BTW, আমি একটি Scala সমাধান খুব পোষ্ট করার সিদ্ধান্ত নিয়েছে করেছি stackoverflow.com/a/43348945/1091436
VasiliNovikov

0

আরও দেখুন এই উত্তরগুলোর

বিশেষত ডিফল্ট সেটিংসের সাথে নীচে দেখানো ফলাফল উত্পাদন করতে অ্যাবেগো ট্রিলআউট ব্যবহার করা খুব কঠিন ছিল না ।

যদি আপনি সেই সরঞ্জামটি চেষ্টা করে থাকেন তবে এই সাবধানবাণীটি নোট করুন: এটি বাচ্চাদের যুক্ত করার ক্রমে মুদ্রণ করে। একটি বিএসটি যেখানে বাম বনাম ডান বিষয়গুলির জন্য আমি এই লাইব্রেরিটি সংশোধন ছাড়াই অনুপযুক্ত বলে মনে করেছি।

এছাড়াও, বাচ্চাদের যুক্ত করার পদ্ধতিটি পরামিতি হিসাবে কেবল একটি parentএবং childনোড নেয় । (সুতরাং একগুচ্ছ নোডগুলি প্রক্রিয়া করতে, আপনাকে অবশ্যই একটি শিকড় তৈরি করতে প্রথমে আলাদাভাবে নিতে হবে))

আমি উপরের এই সমাধানটি ব্যবহার করে শেষ করেছি , এটিকে সংশোধন করে টাইপটি নিতে <Node>যাতে Nodeবাম এবং ডান (শিশুদের) অ্যাক্সেস পেতে পারে ।

অ্যাবেগো ট্রিলআউট দিয়ে তৈরি গাছ


0

আপনার গাছটি দেখার জন্য এখানে আরও একটি উপায় রয়েছে: এক্সএমএল ফাইল হিসাবে নোডগুলি সংরক্ষণ করুন এবং তারপরে আপনার ব্রাউজারটি আপনাকে শ্রেণিবিন্যাস দেখায়:

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();

এবং আউটপুট এই মত দেখাচ্ছে:

এখানে চিত্র বর্ণনা লিখুন


0
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);

    }
}

0

এটি আমি প্রয়োগ করতে পারি এমন একটি সহজতম সংস্করণ। আমি এটি আপনাকে সাহায্য করে আশা করি

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()

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.