Question

所以我已经实施了BST

private String toStringHelper(Node node) {


            if (node == null) {
                return "";
            }
            if (node.left != null) {
                System.out.println(node.left.value);
                toStringHelper(node.left);

            }

            if (node.right != null) {
                System.out.println(node.right.value);
                toStringHelper(node.right);

            }


            return "";
        }

我想使用递归。问题是它不会打印出我的root元素，否则它似乎有用（编辑开始）。当插入以下值100，-12，-13，-1,0,12,10,123,122,124时。它按以下顺序返回： -12 -13 -1 0 12 10 123 122 124显然根本没有订购。（编辑完结后）

问题是我不完全确定递归部分是如何工作的，我想对此进行解释，以便我也可以在适当的位置打印出根。

Answer 1

看起来你将它传递给起始节点，然后打印左右子树。您需要打印作为方法的参数传递的节点的值，然后在节点的左右子节点上调用该方法

private String toStringHelper(Node node) {

        if (node == null) {
            return "";
        }
        //print the value of the current node
        System.out.println(node.value);
        if (node.left != null) {
            //System.out.println(node.left.value);
            toStringHelper(node.left);

        }

        if (node.right != null) {
            //System.out.println(node.right.value);
            toStringHelper(node.right);

        }


        return "";
    }

编辑：将每个OLE V.V.更正的空检查后的print语句移动到

Answer 2

虽然原始问题的答案非常简单并且其他海报已经指出，但我想提供一个关于递归树遍历的更详细的答案，也许这将有助于此帖的未来访问者。树遍历有许多不同的方法，其中一些是“自然”递归的，其中一些不是。（有关详细信息，请参阅wikipedia。）以下代码说明了基于OP中代码的pre / in / post顺序深度优先和广度优先搜索。由于递归（堆栈溢出）的实际限制，深度优先和广度优先都应该使用循环来实现，使用堆栈或队列作为底层数据结构，除非实现是尾递归并且平台可以将其优化为循环，但Java编译器不支持。在下面的代码中，我带来了递归示例，因为关于递归的原始问题，而不是树遍历。

// depth first pre-order
// root
// left child
// left child of left child
// right child of left child
// right child
// left child of right child
// right child of right child
private String toStringHelperDepthFirst(Node node) {
    if (node == null) {
        return "";
    }
    System.out.println(node.value);
    toStringHelper(node.left);
    toStringHelper(node.right); 
}

// depth first in-order
// left child of left child
// left child
// right child of left child
// root
// left child of right child
// right child
// right child of right child
private String toStringHelperDepthFirst(Node node) {
    if (node == null) {
        return "";
    }
    toStringHelper(node.left);
    System.out.println(node.value);
    toStringHelper(node.right); 
}

// depth first post-order
// left child of left child
// right child of left child
// left child
// left child of right child
// right child of right child
// right child
// root
private String toStringHelperDepthFirst(Node node) {
    if (node == null) {
        return "";
    }
    toStringHelper(node.left);
    System.out.println(node.value);
    toStringHelper(node.right); 
}

// breadth-first
// root
// left child
// right child
// left child of left child
// right child of left child
// left child of right child
// right child of right child
private void toStringHelperBreadthFirst(Node node) {
    if(node != null) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(node);
        breadhFirst(queue);
    }
}

private <E> void breadthFirst(Queue<E> queue) {
    if(queue.isEmpty()) {
        return;
    }
    Node node = queue.pop();
    System.err.println(node.value);
    if(node.left != null) {
        queue.add(node.left);
    }
    if(node.right != null) {
        queue.add(node.right)
    }
    breadhFirst(queue);
}

这种递归如何工作＆amp;如何让它打印出根？

2 个答案: