วิธีการพิมพ์แผนภาพต้นไม้ไบนารี


163

ฉันจะพิมพ์ต้นไม้ไบนารีใน Java เพื่อให้ผลลัพธ์เป็นอย่างไร:

   4 
  / \ 
 2   5 

โหนดของฉัน:

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

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

5
นั่นเป็นเรื่องยุ่งยาก ฉันคิดว่าคุณต้องกำหนดความลึกของต้นไม้ก่อน โดยส่วนตัวแล้วฉันจะทิ้งกราฟโหนดลงใน graphviz และปล่อยให้มันจัดการกับมัน :-)
Omnifarious

ดูเหมือนว่าถ้าคุณมีองค์ประกอบมากมายองค์ประกอบรากจะมีขอบขนาดใหญ่ที่มาจากมัน

ฉันมี getDept () วิธีการในต้นไม้
เทียน

1
เพียงเพราะความคิดที่ทำให้ฉันสนุกฉันจึงเขียนโค้ดในภาษาซีพลัสพลัส ต้นไม้ที่จัดรูปแบบสวยงาม
Omnifarious

คำตอบ:


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
วิธีแปลงเอาต์พุตนี้เป็นแนวนอน?
jijesh Aj

สำหรับเอาท์พุทแนวนอนจะดีกว่าที่จะใช้โซลูชั่นของ Vasya Novikov
michal.kreuzman

3
มันจะดีถ้าคุณสามารถเลือก 2 ^ n - 1 เป็นช่องว่างแรกและ 2 ^ (n + 1) - 1 เป็นช่องว่างระหว่าง
DJ '

มันเป็นสิ่งที่ดีสำหรับต้นไม้ที่สมดุลเพราะฉันได้ลองกับต้นไม้ที่มีค่า 15 อันที่เหมาะสมและมันกลายเป็นเรื่องที่ไม่สามารถจัดการได้มากเมื่อเห็นการพิมพ์
akhil_mittal

3
ต้นไม้ของฉันลึก 44 ชั้นดังนั้น Java จึงล้มเหลวเมื่อพยายามพิมพ์ 8796093022207 whitespaces ดังนั้นได้รับคำเตือน
นักเล่นเกม CX

288

พิมพ์ต้นไม้ [ใหญ่] ทีละบรรทัด

ตัวอย่างผลลัพธ์:

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 + "    ");
            }
        }
    }
}

ป.ล. คำตอบนี้ไม่ได้เน้นไปที่ต้นไม้ "binary" โดยตรง แต่จะพิมพ์ต้นไม้ทุกชนิด โซลูชันได้รับแรงบันดาลใจจากคำสั่ง "tree" ใน linux


วิธีการแก้ปัญหานี้จัดการกับต้นไม้ไบนารีเบ้ใช่มั้ย?
patentfox

@VasyaNovikov คุณจะเขียนใหม่children.get(children.size() - 1)อย่างไรถ้าใช้ HashMap สำหรับเด็ก ฉันจัดการเพื่อแก้ไขส่วนอื่น ๆ แต่ส่วนนี้
Le Nguyen Duy Anh

@LeNguyenDuyAnh HashMap เสนอประเภทลายเซ็นอย่างไร HashMap<String, List<String>>?
VasiliNovikov

HashMap<String, Node>ฉันได้ดำเนินต้นไม้ของฉันเป็น String เป็น ID ของโหนด
Le Nguyen Duy Anh

ที่จริงผมดำเนินการบางสิ่งบางอย่างที่คล้ายกันในห้องสมุด Java เล็ก ๆ เรียกว่าข้อความต้นไม้ อาจช่วยใครซักคน
barfuin

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

ที่จะใช้สำหรับต้นไม้ของคุณให้คุณระดับการดำเนินการNodePrintableNode

ตัวอย่างผลลัพธ์:

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

ฉันพยายามทำซ้ำเทคนิค "คำตอบที่เลือก" แต่ฉันคิดว่านี่เป็นคำตอบที่ดีที่สุดที่นี่ แข็งแกร่งและรัดกุม
Vikrant Goel

หลังจากใช้งานสิ่งนี้ดูเหมือนว่าจะใช้งานได้ดี แต่สำหรับต้นไม้ที่สมดุลเท่านั้น อะไรก็ตามที่ไม่สมดุลส่งกลับผลลัพธ์ที่แปลก
mitbanip

ฉันได้รับ???????????แทนเส้นระหว่างโหนด แต่ควรเป็นเพียงแค่ปัญหาบางอย่างของ UTF8 อย่างไรก็ตามสิ่งที่ดีฉันต้องพูด คำตอบที่ดีที่สุดสำหรับฉันเพราะมันใช้งานง่ายมาก
Fitz

ใช่นั่นแหละ เพิ่งต้องเปลี่ยนอักขระพิเศษทั้งหมดของย่อหน้าและย่อหน้าเว้นวรรค
Fitz

ดีเพื่อรองรับการพิมพ์อาร์เรย์ขององค์ประกอบสร้างกระทู้ซึ่งเพิ่งทำโดยใช้ตรรกะ @ 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

นี่คือความแตกต่างจากคำตอบของ @ anurag - มันเป็นการชักนำให้ฉันเห็นสิ่งพิเศษ


มันจะยอดเยี่ยมถ้าคุณหมุนได้ 90 °
Abhijit Sarkar

34

ดัดแปลงมาจากคำตอบของVasya Novikovเพื่อทำให้เป็นไบนารีมากขึ้นและใช้เพื่อประสิทธิภาพ (การเชื่อมวัตถุเข้าด้วยกันใน Java โดยทั่วไปจะไม่มีประสิทธิภาพ)StringBuilderString

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 ใน BST ในขณะที่สร้างต้นไม้ที่เอียงขวา ค่าของ isTail ควรเป็นเท็จเมื่อright != nullฉันทำการแก้ไขและทดสอบมันทำงานได้ดี
akhil_mittal

ขอบคุณสำหรับอินพุตฉันเพิ่งแก้ไขคำตอบมันดีกว่านี้ไหม?
ทอดด์เดวี่ส์

ขอบคุณ @Vasya Novikov คำตอบนั้นยอดเยี่ยม แต่ฉันต้องการเวอร์ชันลิสต์ของมันและคำตอบของคุณก็เหมาะกับเคสของฉัน
hychou

ในคำตอบทั้งหมดนี้ทำให้ได้ต้นไม้ที่ดูดีที่สุดและรหัสนั้นสะอาดมาก!
p-sun

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

วางฟังก์ชั่นนี้กับ TreeNode ที่คุณระบุและรักษาระดับเริ่มต้นที่ 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, N, O]]

หากทรีของคุณไม่เต็มคุณจะต้องรวมค่าว่างในอาเรย์นั้น:

       
      / \
     / \
    / \
   / \
   ก่อนคริสต์ศักราช
  / \ / \
 / \ / \
 DEFG
/ \ \ / \ \
hiklmo
[[a], [b, c], [d, e, f, g], [h, i,, k, l, m,, o]]

จากนั้นคุณสามารถวนซ้ำอาร์เรย์เพื่อพิมพ์ต้นไม้ของคุณพิมพ์ช่องว่างก่อนองค์ประกอบแรกและระหว่างองค์ประกอบขึ้นอยู่กับความลึกและการพิมพ์บรรทัดขึ้นอยู่กับว่าองค์ประกอบที่สอดคล้องกันในอาร์เรย์สำหรับชั้นถัดไปจะเต็มหรือไม่ หากค่าของคุณมีความยาวมากกว่าหนึ่งตัวอักษรคุณจะต้องค้นหาค่าที่ยาวที่สุดในขณะที่สร้างการแทนค่าอาร์เรย์และคูณความกว้างทั้งหมดและจำนวนบรรทัดตามลำดับ


เกิดอะไรขึ้นถ้าต้นไม้ไม่สมบูรณ์ ในกรณีนี้ดูเหมือนว่าคุณควรจะสามารถทำได้โดยไม่ต้องเพิ่มพื้นที่ในแต่ละระดับ
templatetypedef

ใช่ แต่ในบางกรณีที่มีข้อ จำกัด บางอย่างที่ subtrees ส่วนใหญ่เชื่อมโยงรายชื่อแทนที่จะเป็นต้นไม้จากระดับเดียวกันหรือคุณอาจวาด subtrees ที่แตกต่างกันด้วยระยะห่างระหว่างเลเยอร์ที่แตกต่างกัน ...
hd42

13

ฉันพบคำตอบของ VasyaNovikov มีประโยชน์มากสำหรับการพิมพ์ต้นไม้ทั่วไปขนาดใหญ่และแก้ไขสำหรับต้นไม้ไบนารี

รหัส:

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
ด้วย Lambda ที่มีใน Java ด้วยคุณอาจต้องการอัปเดตโซลูชัน Java ของคุณหรือไม่
ตินติน

@ ตินตินสกาล่าไม่ได้เป็นเพียงแค่ฟังก์ชั่นแลมบ์ดาเท่านั้น แต่ถ้าคุณมีการปรับปรุงที่ดีสำหรับ Java อยู่ในใจอย่าลังเลที่จะ "แก้ไข" ซึ่งจะได้รับการยอมรับจากชุมชน StackOverflow หากถือว่าเป็นประโยชน์;)
27819

5

ฉันรู้ว่าพวกคุณทุกคนมีทางออกที่ดี ฉันแค่อยากจะแบ่งปันของฉัน - บางทีนั่นอาจไม่ใช่วิธีที่ดีที่สุด แต่มันก็เหมาะสำหรับฉัน!

ด้วยpythonและpipในวันที่มันเป็นจริงค่อนข้างง่าย! BOOM!

บน Mac หรือ Ubuntu (ของฉันคือ mac)

  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

การติดตามแหล่งที่มา:

ก่อนที่ฉันจะเห็นโพสต์นี้ฉันไป google "ข้อความต้นไม้ไบนารีธรรมดา"

และฉันพบhttps://www.reddit.com/r/learnpython/comments/3naiq8/draw_binary_tree_in_plain_text/โปรดพาฉันไปที่https://github.com/msbanik/drawtree


@DenysVitali โอ้ใช่คุณพูดถูก): ฉันอาจจะย้ายสิ่งนี้ไปเป็น 'วิธีการพิมพ์ต้นไม้จาก traversal ลำดับระดับต่อเนื่อง (ภาษาใด ๆ / หลาม)'
Sean L

3
ผมไม่ได้อยากจะดูหยาบ แต่เมื่อผู้ใช้แท็กคำถามเป็นjavaเขาคาดหวังคำตอบ 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

ขึ้นอยู่กับคำตอบ VasyaNovikov ปรับปรุงด้วยเวทมนตร์ของ Java บางประการ: Generics และอินเตอร์เฟสที่ใช้งานได้

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

ฉันเขียนเครื่องพิมพ์ต้นไม้ไบนารีใน Java

รหัสคือบน GitHub ที่นี่

มันไม่ได้รับการปรับให้เหมาะสมสำหรับประสิทธิภาพเวลาทำงาน แต่เนื่องจากเรากำลังพูดถึงการพิมพ์ใน ASCII ฉันคิดว่ามันจะไม่ถูกใช้บนต้นไม้ขนาดใหญ่มาก มันมีคุณสมบัติที่ดีบางอย่าง

  1. มันทำให้การใช้พื้นที่อย่างมีประสิทธิภาพในทรีย่อยขนาดใหญ่ขยายไปถึงอันที่เล็กกว่ามากที่สุด
  2. มีพารามิเตอร์ในการกำหนดช่องว่างแนวนอนต่ำสุดระหว่างป้ายชื่อโหนด
  3. ป้ายชื่อโหนดเป็นสตริงของความยาวโดยพลการ
  4. นอกเหนือจากวิธีการพิมพ์ต้นไม้เดียวแล้วยังมีวิธีการพิมพ์รายการต้นไม้ในแนวนอนทั่วทั้งหน้า (พร้อมพารามิเตอร์สำหรับความกว้างของหน้ากระดาษ) โดยใช้แถวจำนวนเท่าที่จำเป็น
  5. มีตัวเลือกในการพิมพ์ต้นไม้ที่มีสาขาในแนวทแยง (ใช้อักขระทับและทับขวา) หรือกับสาขาแนวนอน (โดยใช้อักขระวาดกล่อง ASCII) หลังมีขนาดกะทัดรัดและทำให้ระดับต้นไม้ชัดเจนขึ้น
  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 และมีกิ่งในแนวทแยงและแนวนอน

                   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               

เป็นเรื่องที่ดีที่คุณเขียนโปรเจคนี้ ดูเหมือนว่าจะทำงานได้ดี แต่โดยทั่วไปแล้วลิงก์ไปยังห้องสมุดของคุณไม่ได้ตอบคำถามที่ดีเกี่ยวกับ Stack Overflow อย่างน้อยที่สุดคุณควรใส่รหัสที่จำเป็นในการใช้ห้องสมุดของคุณเพื่อแสดงตัวอย่างที่คุณให้ไว้เพื่อให้คนอื่นรู้ว่ามีส่วนเกี่ยวข้องกับการใช้ห้องสมุดของคุณอย่างไร ตอนนี้นี่เป็นเพียงโฆษณาสำหรับ repo GitHub ของคุณ นั่นไม่ใช่เรื่องเลวร้ายถ้าคุณแสดงให้คนอื่นเห็นว่าจะใช้มันอย่างไร
Makyen

BTW: หากคุณแก้ไขในโค้ดตัวอย่างโปรด ping ฉันที่นี่โดยรวม@Makyenไว้ในความคิดเห็น
Makyen

2

นี่เป็นคำถามที่น่าสนใจและฉันก็เขียนโครงการให้ด้วย

ไบนารีต้นไม้เครื่องพิมพ์

นี่คือตัวอย่างบางส่วน:

พิมพ์ BST แบบสุ่ม

BTPrinter.printRandomBST(100, 100);
                              38                                  
                              / \                                 
                             /   \                                
                            /     \                               
                           /       \                              
                          /         \                             
                         /           \                            
                        /             \                           
                       /               \                          
                      /                 \                         
                     /                   \                        
                    /                     \                       
                   /                       \                      
                  /                         \                     
                 /                           \                    
                /                             \                   
               /                               \                  
              28                               82                 
             / \                               / \                
            /   \                             /   \               
           /     \                           /     \              
          /       \                         /       \             
         5        31                       /         \            
        / \       / \                     /           \           
       /   \     30 36                   /             \          
      /     \   /   / \                 /               \         
     /       \ 29  33 37               /                 \        
    /         \   / \                 /                   \       
   /           \ 32 35               65                   95      
  1            14   /               / \                   / \     
 / \           / \ 34              /   \                 94 97    
0   2         /   \               /     \               /   / \   
     \       12   24             /       \             93  96 98  
      3     / \   / \           /         \           /         \ 
       \   9  13 16 25         /           \         84         99
        4 / \   / \   \       /             \       / \           
         7  10 15 23  26     59             74     83 86          
        / \   \   /     \   / \             / \       / \         
       6   8  11 22     27 56 60           73 76     85 91        
                /         / \   \         /   / \       / \       
               20        /   \  61       67  75 79     88 92      
              / \       40   58   \     / \     / \   / \         
             18 21     / \   /    62   66 72   78 80 87 89        
            / \       39 54 57      \     /   /     \     \       
           17 19         / \        64   69  77     81    90      
                        50 55       /   / \                       
                       / \         63  68 70                      
                      /   \                 \                     
                     /     \                71                    
                    47     53                                     
                   / \     /                                      
                  /   \   52                                      
                 42   49 /                                        
                / \   / 51                                        
               41 43 48                                           
                    \                                             
                    46                                            
                    /                                             
                   45                                             
                  /                                               
                 44     

พิมพ์ทรีจากอาร์เรย์ลำดับระดับ leetcode ในรูปแบบ '#' หมายถึงจุดสิ้นสุดพา ธ ที่ไม่มีโหนดด้านล่าง

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

ฉันต้องการพิมพ์ต้นไม้ไบนารีในโครงการของฉันเพื่อที่ฉันได้เตรียมคลาส java 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. พิมพ์ปมเป็นวงกลมด้วยรัศมีที่มองเห็นได้บางส่วน

    • รับพิกัดสำหรับแต่ละโหนด

    • พิกัด x สามารถมองเห็นได้เป็นจำนวนโหนดที่เยี่ยมชมก่อนที่โหนดจะเข้าชมในการแวะผ่าน inorder

    • พิกัด y สามารถมองเห็นได้เป็นความลึกของโหนดเฉพาะ


  1. พิมพ์บรรทัดระหว่างพาเรนต์และลูก

    • สิ่งนี้สามารถทำได้โดยการรักษาพิกัด x และ y ของโหนดและพาเรนต์ของแต่ละโหนดในรายการแยกกัน

    • สำหรับแต่ละโหนดยกเว้นรูทเข้าร่วมแต่ละโหนดกับพาเรนต์โดยรับค่าพิกัด x และ y ของทั้งลูกและพาเรนต์


คุณช่วยนึกภาพและให้ทางออกที่ดีกว่าคำตอบที่มีอยู่ได้ไหม?
Enamul Hassan

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

นี่เป็นวิธีที่ง่ายที่สุดสำหรับมุมมองแนวนอน พยายามกับตัวอย่างมากมาย ทำงานได้ดีสำหรับวัตถุประสงค์ของฉัน อัปเดตจากคำตอบของ @ nitin-k

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. คุณจะต้องปรับลำดับการสำรวจต้นไม้ของคุณ
  2. เลือกความยาวโหนดและความยาวพื้นที่ระยะเวลาในพื้นที่
  3. รับต้นไม้ฐานกว้างเมื่อเทียบกับแต่ละระดับnode_length * nodes_count + space_length * spaces_count*ซึ่งเป็น
  4. ค้นหาความสัมพันธ์ระหว่างการแยกระยะห่างการเยื้องและความกว้างฐานที่คำนวณได้

รหัสใน GitHub: YoussefRaafatNasry / bst-ascii-visualization

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

ฉันว่ารหัสสั้นพอที่คุณสามารถฝังไว้ในคำตอบของคุณ
m02ph3u5

รหัสไม่ได้เป็นเพียงvisualizeฟังก์ชั่น แต่เป็นvisualizerคลาสทั้งหมดซึ่งมีประมาณ 200 loc รวมถึงไฟล์ส่วนหัว
YoussefRaafatNasry

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

คลาส NodeInfo

package com.tomac120.NodePrinter;

/**
 * Created by elijah on 6/28/16.
 */
public class PrintableNodeInfo {
    public enum CLI_PRINT_COLOR {
        RESET("\u001B[0m"),
        BLACK("\u001B[30m"),
        RED("\u001B[31m"),
        GREEN("\u001B[32m"),
        YELLOW("\u001B[33m"),
        BLUE("\u001B[34m"),
        PURPLE("\u001B[35m"),
        CYAN("\u001B[36m"),
        WHITE("\u001B[37m");

        final String value;
        CLI_PRINT_COLOR(String value){
            this.value = value;
        }

        @Override
        public String toString() {
            return value;
        }
    }
    private final String title;
    private final PrintableNode leftChild;
    private final PrintableNode rightChild;
    private final CLI_PRINT_COLOR textColor;

    public PrintableNodeInfo(String title, PrintableNode leftChild, PrintableNode rightChild){
        this(title,leftChild,rightChild,CLI_PRINT_COLOR.BLACK);
    }

    public PrintableNodeInfo(String title, PrintableNode leftChild, PrintableNode righthild, CLI_PRINT_COLOR textColor){
        this.title = title;
        this.leftChild = leftChild;
        this.rightChild = righthild;
        this.textColor = textColor;
    }

    public String getTitle(){
        return title;
    }

    public CLI_PRINT_COLOR getTextColor(){
        return textColor;
    }

    public String getTitleFormatted(int max_chars){
        return this.textColor+title+CLI_PRINT_COLOR.RESET;
        /*
        String title = this.title.length() > max_chars ? this.title.substring(0,max_chars+1):this.title;
        boolean left = true;
        while(title.length() < max_chars){
            if (left){
                title = " "+title;
            } else {
                title = title + " ";
            }
        }
        return this.textColor+title+CLI_PRINT_COLOR.RESET;*/
    }

    public int getTitleLength(){
        return title.length();
    }

    public PrintableNodeInfo getLeftChildInfo(){
        if (leftChild == null){
            return null;
        }
        return leftChild._getPrintableNodeInfo();
    }

    public PrintableNodeInfo getRightChildInfo(){
        if (rightChild == null){
            return null;
        }
        return rightChild._getPrintableNodeInfo();
    }
}

คลาส NodePosition

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

และในที่สุด Node Interface

package com.tomac120.NodePrinter;

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

0

โซลูชัน Scala ดัดแปลงมาจากคำตอบของ Vasya Novikov และเฉพาะสำหรับต้นไม้ไบนารี:

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

ดูคำตอบเหล่านี้ด้วย

โดยเฉพาะอย่างยิ่งมันไม่ยากเกินไปที่จะใช้abego TreeLayoutเพื่อสร้างผลลัพธ์ที่แสดงด้านล่างด้วยการตั้งค่าเริ่มต้น

หากคุณลองใช้เครื่องมือนี้ให้สังเกตข้อแม้นี้: มันจะพิมพ์ลูกตามลำดับที่เพิ่มเข้ามา สำหรับ BST ที่ left vs right สำคัญฉันพบว่าไลบรารี่นี้ไม่เหมาะสมโดยไม่มีการดัดแปลง

นอกจากนี้วิธีการเพิ่มลูกก็ใช้เวลาparentและchildโหนดเป็นพารามิเตอร์ (ดังนั้นในการประมวลผลโหนดจำนวนมากคุณต้องแยกโหนดแรกเพื่อสร้างรูท)

ฉันลงเอยด้วยการใช้วิธีแก้ปัญหาข้างต้นปรับเปลี่ยนให้เป็นรูปแบบ<Node>เพื่อให้สามารถเข้าถึงNodeซ้ายและขวา (เด็ก ๆ )

ต้นไม้ที่สร้างขึ้นด้วย abego TreeLayout


0

นี่เป็นอีกวิธีหนึ่งในการสร้างภาพต้นไม้ของคุณ: บันทึกโหนดเป็นไฟล์ xml จากนั้นให้เบราว์เซอร์ของคุณแสดงลำดับชั้น:

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.