आप एक अच्छी तरह से स्वरूपित तरीके से एक पेड़ कैसे मुद्रित कर सकते हैं?

Question

पेड़-संरचना में पेड़ को मुद्रित करने का सबसे आसान तरीका क्या है? जैसे ...

    some root 
      / |   \ 
      child1 child2  child 3 
     /
     anotherchild    /\ 
          yup  another 

हाथ से इसे स्वरूपित करना भी मुश्किल है। इस कार्यक्रम को एक पेड़ कैसे प्रिंट कर सकते हैं?

Answer 1

ठीक है, आप PHP के var_dump की तरह कुछ की कोशिश कर सकते हैं - यदि आप एक पेड़ की तरह सरणी पर var_dump कोशिश है, यह आपको लगता है कि पेड़ की एक उचित प्रतिनिधित्व दे देंगे, वह यह है कि:

root { 
    child1 { 
     anotherchild 
    } 
    child2 
    child3 { 
     yup 
     another 
    } 
} 

Answer 2

हालांकि मैं नहीं था ' इसे स्वयं कोशिश नहीं करें, graphviz में सादा पाठ output format है।

Answer 3

जब तक कि आप कुछ अच्छी ग्राफिकल लाइब्रेरी का उपयोग नहीं कर सकते हैं, तो आपको वर्णन के तरीके में पदानुक्रम का प्रतिनिधित्व करने में बहुत सारी परेशानी होगी।

मान लीजिए कि आप इसे कंसोल या फ़ाइल में प्रिंट करना चाहते हैं, तो आपको उन्हें सही तरीके से लाइन करने के लिए पूरे पेड़ के सभी डेटा तत्वों की लंबाई की गणना करने के साथ संघर्ष करना होगा। और आप लाइन-रैप जैसी चीजों को कैसे संभालेंगे?

बच्चे तत्व को दिखाने के लिए इंडेंटेशन का उपयोग करके पेड़ को लंबवत रूप से प्रस्तुत करने का एक बेहतर तरीका है।

Root 
    - Child1 
     - Grandchild1 
     - Grandchild2 
    - Child2 
     - Grandchild3 
     - Grandchild4 

यह कोड के लिए बहुत आसान है, और लाइनवाप जैसी चीजों की अधिक सहनशीलता है - क्योंकि लाइन पर केवल एक ही तत्व है। इस प्रकार एक फ़ोल्डर-ब्राउज़र या एक्सएमएल दस्तावेज़ अपने पदानुक्रमित डेटा को प्रदर्शित कर सकता है।

यह इस तरह से करने के लिए, आप एक गहराई-प्रथम ट्रेवर्सल करते हैं और पुनरावर्ती कदम इससे पहले कि आप नोड प्रिंट आउट:

public void PrintNode(TreeNode node) 
{ 
    PrintNode(node, 0); 
} 

private void PrintNode(TreeNode node, int indentation) 
{ 
    // Print the value to the console/file/whatever 
    // This prefixes the value with the necessary amount of indentation 
    Print(node.Value, indentation); 

    // Recursively call the child nodes. 
    foreach(TreeNode childNode in node.Children) 
    { 
     PrintNode(childNode, indentation + 1); // Increment the indentation counter. 
    } 
} 

आशा है कि मदद करता है

Answer 4

कैसे के बारे में this answer एक समान प्रश्न के लिए? यह एक अच्छा ASCII- कला पेड़ प्रिंट करता है।

या शायद this one यदि आप पूरी तरह से ग्राफिकल जाना चाहते हैं?

Answer 5

मुझे पिछले साल यह एक पारिवारिक वृक्ष आवेदन लिखना पड़ा था। ऑनलाइन एक जावा ट्यूटोरियल मिला जिसने मदद की लेकिन मेरा Google-fu आज मुझे असफल रहा, इसलिए मुझे बस इसे समझाना होगा।

यह केवल एक रिकर्सिव एल्गोरिदम है जो बाल नोड्स के आधार पर पैरेंट नोड की स्थिति समायोजित करता है।

positionNode (node,x,y) { 
    foreach (child in node.children) { 
     positionNode(child,x,y+1) 
     x ++ 
    } 
    node.x = (x-1)/2 
    node.y = y 
} 

मैं इस सही ढंग से याद नहीं किया जा सकता है, आप इसे सही करने के लिए कोड में थोड़ा बदलाव करने की आवश्यकता हो सकती: स्यूडोकोड में यह कुछ इस तरह है।

Answer 6

निम्नलिखित जवाब जावा में है, लेकिन यह इतना आसान है कि यह आसानी से अन्य भाषाओं में बदल दिया जा सकता है:

public interface Function1<R, T1> 
{ 
    R invoke(T1 argument1); 
} 

public interface Procedure1<T1> 
{ 
    void invoke(T1 argument1); 
} 

public static <T> void dump(T node, Function1<List<T>,T> breeder, 
     Function1<String,T> stringizer, Procedure1<String> emitter) 
{ 
    emitter.invoke(stringizer.invoke(node)); 
    dumpRecursive(node, "", breeder, stringizer, emitter); 
} 

private static final String[][] PREFIXES = { { " ├─ ", " │ " }, { " └─ ", " " } }; 

private static <T> void dumpRecursive(T node, String parentPrefix, 
     Function1<List<T>,T> breeder, Function1<String,T> stringizer, 
     Procedure1<String> emitter) 
{ 
    for(Iterator<T> iterator = breeder.invoke(node).iterator(); iterator.hasNext();) 
    { 
     T childNode = iterator.next(); 
     String[] prefixes = PREFIXES[iterator.hasNext()? 0 : 1]; 
     emitter.invoke(parentPrefix + prefixes[0] + stringizer.invoke(childNode)); 
     dumpRecursive(childNode, parentPrefix + prefixes[1], breeder, stringizer, emitter); 
    } 
} 

यह निम्न उत्पादन का उत्पादन:

Automobile 
├─ Passenger Vehicle 
│ ├─ Light Passenger Vehicle 
│ │ ├─ Two Wheeled 
│ │ │ ├─ Moped 
│ │ │ ├─ Scooter 
│ │ │ └─ Motorcycle 
│ │ ├─ Three Wheeled 
│ │ └─ Four Wheeled 
│ │  ├─ Car 
│ │  ├─ Station Wagon 
│ │  ├─ Pick-up Truck 
│ │  └─ Sports Utility Vehicle 
│ └─ Heavy Passenger Vehicle 
│  ├─ Bus 
│  │ ├─ Single-Deck Bus 
│  │ │ ├─ Mini Bus 
│  │ │ └─ Big Bus 
│  │ └─ Double-Deck Bus 
│  └─ Coach 
│   ├─ Deluxe 
│   └─ Air-Conditioned 
└─ Goods Vehicle 
    ├─ Light Goods Vehicle 
    │ ├─ Delivery Van 
    │ ├─ Light Truck 
    │ └─ Tempo 
    │  ├─ Three Wheeler Tempo 
    │  └─ Four Wheeler Tempo 
    └─ Heavy Goods Vehicle 
     ├─ Truck 
     └─ Tractor Trailer 

...यदि आप इसे निम्न नमूना प्रोग्राम का उपयोग आह्वान:

final class Scratch 
{ 
    static class Node 
    { 
     String name; 
     List<Node> children; 

     Node(String name, Node... children) 
     { 
      this.name = name; 
      this.children = Arrays.asList(children); 
     } 
    } 

    public static void main(String[] args) 
    { 
     Node tree = new Node("Automobile", 
       new Node("Passenger Vehicle", 
         new Node("Light Passenger Vehicle", 
           new Node("Two Wheeled", 
             new Node("Moped"), 
             new Node("Scooter"), 
             new Node("Motorcycle")), 
           new Node("Three Wheeled"), 
           new Node("Four Wheeled", 
             new Node("Car"), 
             new Node("Station Wagon"), 
             new Node("Pick-up Truck"), 
             new Node("Sports Utility Vehicle"))), 
         new Node("Heavy Passenger Vehicle", 
           new Node("Bus", 
             new Node("Single-Deck Bus", 
               new Node("Mini Bus"), 
               new Node("Big Bus")), 
             new Node("Double-Deck Bus")), 
           new Node("Coach", 
             new Node("Deluxe"), 
             new Node("Air-Conditioned")))), 
       new Node("Goods Vehicle", 
         new Node("Light Goods Vehicle", 
           new Node("Delivery Van"), 
           new Node("Light Truck"), 
           new Node("Tempo", 
             new Node("Three Wheeler Tempo"), 
             new Node("Four Wheeler Tempo"))), 
         new Node("Heavy Goods Vehicle", 
           new Node("Truck"), 
           new Node("Tractor Trailer")))); 
     dump(tree, n -> n.children, n -> n.name, s -> System.out.println(s)); 
    } 
}