二叉树图形输出java,输出二叉树的树形图

发布时间：2022-11-19

本文目录一览：

  1. 怎样用Java来体现二叉树（顺便加上注释）
  2. 求Java实现二叉树！！！
  3. java中把数组以二叉树形式打印出来
  4. java一个关于二叉树的简单编程题
  5. 想要把一棵二叉树图形输出，请问有什么好算法

怎样用Java来体现二叉树（顺便加上注释）

二叉树，和数据库的B树操作流程是一样的，例如：有如下字段 F,C,B,H,K,I； 如果要形成二叉树的话，则，首先取第一个数据作为根节点，所以，现在是 F ，如果字段比根节点小，则保存在左子树，如果比根节点大或者等于根节点则保存在右子树，最后按左---根-----右输出所以数据。 所以，实现的关键就是在于保存的数据上是否存在大小比较功能，而String类中compareTo()有这个能力,节点类要保存两类数据，左节点，右节点

class Node {
    private String data;
    private Node left;
    private Node right;
    public Node(String data) {
        this.data = data;
    }
    public void setLeft(Node left) {
        this.left = left;
    }
    public void setRight(Node right) {
        this.right = right;
    }
    public String getDate() {
        return this.data;
    }
    public Node getLeft() {
        return this.left;
    }
    public Node getRight() {
        return this.right;
    }
    public void addNode(Node newNode) {
        if (this.data.compareTo(newNode.data) == 0) {
            if (this.left == null) {
                this.left = newNode;
            } else {
                this.left.addNode(newNode);
            }
        } else {
            if (this.right == null) {
                this.right = newNode;
            } else {
                this.right.addNode(newNode);
            }
        }
    }
    public void printNode() {
        if (this.left != null) {
            this.left.printNode();
        }
        System.out.println(this.data);
        if (this.right != null) {
            this.right.printNode();
        }
    }
}
class BinaryTree {
    private Node root = null;
    public void add(String data) {
        Node newNode = new Node(data);
        if (this.root == null) {
            this.root = newNode;
        } else {
            this.root.addNode(newNode);
        }
    }
    public void print() {
        this.root.printNode();
    }
}
public class Hello {
    public static void main(String args[]) {
        BinaryTree link = new BinaryTree();
        link.add("F");
        link.add("C");
        link.add("B");
        link.add("H");
        link.add("K");
        link.add("I");
        link.print();
    }
}

你一看就英文就知道什么意思了，应该可以理解了 这个二叉树捉摸不透就别琢磨了，开放中一般用不上

求Java实现二叉树！！！

public class TreeNode1 { // 二叉树的结点类
    public String data; // 数据元素
    public TreeNode1 left, right; // 指向左,右孩子结点的链
    public TreeNode1() {
        this("?");
    }
    public TreeNode1(String d) { // 构造有值结点
        data = d;
        left = right = null;
    }
    public void preorder(TreeNode1 p) { // 先根次序遍历二叉树
        if (p != null) {
            System.out.print(p.data + " ");
            preorder(p.left);
            preorder(p.right);
        }
    }
    public void inorder(TreeNode1 p) { // 中根次序遍历二叉树
        if (p != null) {
            inorder(p.left);
            System.out.print(p.data + " ");
            inorder(p.right);
        }
    }
    public void postorder(TreeNode1 p) { // 后根次序遍历二叉树
        if (p != null) {
            postorder(p.left);
            postorder(p.right);
            System.out.print(p.data + " ");
        }
    }
}

java中把数组以二叉树形式打印出来

你说的意思应该是用数组的方式存储二叉树，这需要利用到完全二叉树的性质， 完全二叉树通常采用数组而不是链表存储,其存储结构如下:

var
tree: array[1..n] of
longint; {n: integer; n=1}

对于tree[i]，有如下特点：

  1. 若i为奇数且i>1，那么tree的左兄弟为tree[i-1]；
  2. 若i为偶数且i<n，那么tree的右兄弟为tree[i+1]；
  3. 若i>1，tree的双亲为tree[i div 2]；
  4. 若2i<=n，那么tree的左孩子为tree[2i]；若2i+1<=n，那么tree的右孩子为tree[2i+1]；
  5. 若i > n div 2, 那么tree[i]为叶子结点（对应于（3））；
  6. 若i <= (n-1) div 2. 那么tree[i]必有两个孩子（对应于（4））；
  7. 满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。 完全二叉树第i层至多有2^（i-1）个节点，共i层的完全二叉树最多有2^i-1个节点。 代码简单，网上很多，不懂也可以问我。

java一个关于二叉树的简单编程题

定义一个结点类：

public class Node {
    private int value;
    private Node leftNode;
    private Node rightNode;
    public Node getRightNode() {
        return rightNode;
    }
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
    public Node getLeftNode() {
        return leftNode;
    }
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
}

初始化结点树：

public void initNodeTree() {
    int nodeNumber;
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    Node nodeTree = new Node();
    Scanner reader = new Scanner(System.in);
    nodeNumber = reader.nextInt();
    for (int i = 0; i < nodeNumber; i++) {
        int value = reader.nextInt();
        String str = reader.next();
        map.put(str, value);
    }
    if (map.containsKey("#")) {
        int value = map.get("#");
        nodeTree.setValue(value);
        setChildNode(map, value, nodeTree);
    }
    preTraversal(nodeTree);
}
private void setChildNode(HashMap<String, Integer> map, int nodeValue, Node parentNode) {
    int value = 0;
    if (map.containsKey("L" + nodeValue)) {
        value = map.get("L" + nodeValue);
        Node leftNode = new Node();
        leftNode.setValue(value);
        parentNode.setLeftNode(leftNode);
        setChildNode(map, value, leftNode);
    }
    if (map.containsKey("R" + nodeValue)) {
        value = map.get("R" + nodeValue);
        Node rightNode = new Node();
        rightNode.setValue(value);
        parentNode.setRightNode(rightNode);
        setChildNode(map, value, rightNode);
    }
}

前序遍历该结点树：

public void preTraversal(Node nodeTree) {
    if (nodeTree != null) {
        System.out.print(nodeTree.getValue() + "\t");
        preTraversal(nodeTree.getLeftNode());
        preTraversal(nodeTree.getRightNode());
    }
}

想要把一棵二叉树图形输出，请问有什么好算法

建立语法树后，对语法树的结点赋坐标值，主要算法是用后序遍历算法，定下坐标。具体定坐标时候先获得当前客户区左右两点坐标，然后取中值作为根结点坐标，对于左孩子坐标，则根结点坐标和左边框坐标取中点，右孩子坐标类似，递归调用，把所有信息保存在一个vector的vec数组里面。 这种画二叉树的算法，输出的图形层次数多的时候那些结点会重叠，像一串葡萄，我想改一下这个算法，可是不知道怎么改好，请诸位帮个忙吧 。 另外还有一种算法也是用到递归，具体是先定好根结点坐标，然后再根据根结点坐标加减一个距离值来定左右孩子坐标，每次递归距离值就减少一个定值，这样对于一个多层树可以显示，可是二叉树如果左（右）子树层次太多，有一些结点就会看不到了的。这个算法同样也不知道怎么改好，诸位帮忙。

推荐文章