如何在Java二进制搜索树中将值打印为长字符串？

Question

所以我试图将值打印为我所有节点在BST中都具有的长字符串，问题是我找不到一种方法来保留这些值，因为它们是递归方法（inOrder preOrder postOrder），我怎么做？ 当我尝试逐行打印每个值时，我的代码有效。 提前致谢！

例如，我有这些名字，我想使用BST按字母顺序打印出来：杰里，伊莱恩，拉尔夫，爱丽丝，乔治，苏珊，诺顿，特里西。 我想要的结果：[爱丽丝] [伊莱恩] [乔治] [杰里] [诺顿] [拉尔夫] [苏珊] [特里克西]

import java.util.Random;

public class TreeNode {

    private String value;
    private TreeNode left;
    private TreeNode right;

    public TreeNode(String n) {
        value = n;
        left = right = null;
    }

    public void insert(String n) {
        if (n.compareTo(value) <= 0) {
            if (left == null) {
                left = new TreeNode(n);
            } else {
                left.insert(n);
            }
        } else {
            if (right == null) {
                right = new TreeNode(n);
            } else {
                right.insert(n);
            }
        }
    }

    public boolean contains(String n) {
        if (n == value) {
            return true;
        } else if (n.compareTo(value) <= 0) {
            if (left == null) {
                return false;
            } else {
                return left.contains(n);
            }
        } else {
            if (right == null) {
                return false;
            } else {
                return right.contains(n);
            }
        }
    }

    public TreeNode remove(String n) {
        if (n.compareTo(value) < 0) {
            if (left != null) {
                left = left.remove(n);
            }
        } else if (n.compareTo(value) > 0) {
            if (right != null) {
                right = right.remove(n);
            }
        } else {
            if (left == null && right == null) {
                return null;
            } else if (left != null && right == null) {
                return left;
            } else if (left == null && right != null) {
                return right;
            } else {
                Random r = new Random();
                if (r.nextBoolean()) {
                    value = left.rightMost();
                    left = left.remove(value);
                } else {
                    value = right.leftMost();
                    right = right.remove(value);
                }
            }
        }
        return this;
    }

    public String leftMost() {
        if (left == null) {
            return value;
        } else {
            return left.leftMost();
        }
    }

    public String rightMost() {
        if (right == null) {
            return value;
        } else {
            return right.rightMost();
        }
    }

    public String inOrder() {

        String temp = null;
        if (left != null) {
            left.inOrder();
        }

        temp = "["+value+"]";

        if (right != null) {
            right.inOrder();
        }

        return temp;

    }

public class BinarySearchTree {

    private TreeNode root;

    public BinarySearchTree() {
        root = null;
    }

    public void insert(String n) {
        if (root == null) {
            root = new TreeNode(n);
        } else {
            root.insert(n);
        }
    }

    public boolean contains(String n) {
        if (root == null) {
            return false;
        } else {
            return root.contains(n);
        }
    }

    public void remove(String n) {
        if (root != null) {
            root = root.remove(n);
        }
    }

    public String inOrder() {

        if (root != null) {
            root.inOrder();
        }
        return root.inOrder();
    }

Answer 1

您可以使用泛型类型 。 类似BinarySearchTree<T> ，其中T可以是任何类型的对象。 然后，在使用它时，可以将其初始化为BinarySearchTree<String> ，以防需要处理String

Answer 2

您可以在TreeNode类中具有静态String变量。 由于变量的一个副本可用于所有实例，因此可以在遍历时附加值。

例如： myPath += "["+value+"]"; 您的temp = "["+value+"]"; 是

遍历完成后，您可以打印TreeNode.myPath 。

Answer 3

只需将调用左侧和右侧子树的inOrder的结果连接起来即可。

public String inOrder() {
    String temp = "[" + value +"]";
    if (left != null) {
        temp = left.inOrder() + temp;
    }

    if (right != null) {
        temp = temp + right.inOrder();
    }
    return temp;
}