Question

我试图在二叉树（不是二叉搜索树）中跟踪节点的路径。给定一个节点，我试图从根目录打印路径的值。

alt text

我写了以下程序。

package dsa.tree;

import java.util.Stack;

public class TracePath {
    private Node n1;

    public static void main(String args[]){
        TracePath nodeFinder = new TracePath();
        nodeFinder.find();
    }

    public void find(){
        Tree t = getSampleTree();
        tracePath(t,n1);
    }

    private Tree getSampleTree() {
        Tree bsTree = new BinarySearchTree();
        int randomData[] = {43,887,11,3,8,33,6,0,46,32,78,76,334,45};
        for(int i=0;i<randomData.length;i++){
            bsTree.add(randomData[i]);
        }
        n1 = bsTree.search(76);
        return bsTree;
    }

    public void tracePath(Tree t, Node node){
        trace(t,node);
    }

    Stack<Node> mainStack = new Stack<Node>();

    public void trace(Tree t, Node node){
        trace(t.getRoot(),node);
    }

    private void trace(Node parent, Node node){
        mainStack.push(parent);
        if(node.data == parent.data){
            for(Node iNode:mainStack){
                System.out.println(iNode.data);
            }
            return;
        }
        if(parent.left != null){
            trace(parent.left, node);
        }
        if(parent.right!=null){
            trace(parent.right, node);
        }
        mainStack.pop();
    }
}

我正确地获得输出。但它有点凌乱。如果你看到方法跟踪（节点，节点），我打印的是我不应该做的值。我希望跟踪方法正确完成。至少，我应该在遇到if条件的阶段杀死递归结构。

请告知。

Answer 1

好的，你需要在找到节点后终止递归。很简单。更改trace方法以返回一个布尔值，告诉我们是否找到了节点。这样，我们在找到节点后立即回到树上。

private boolean trace(Node parent, Node node){
    mainStack.push(parent);
    if(node.data == parent.data){
        for(Node iNode:mainStack){
            System.out.println(iNode.data);
        }
        return true;
    }
    if(parent.left != null){
        if (trace(parent.left, node)) return true;
    }
    if(parent.right!=null){
        if (trace(parent.right, node)) return true;
    }
    mainStack.pop();
    return false;
}

Answer 2

我认为这是作业，所以我会给出一些指示而不是一些代码。

您的trace方法执行递归下降，因此不需要堆栈 - 您可以在从找到的节点返回时构建路径结构
如果您的方法使用布尔值或列表返回值，则可以在返回时打印路径，或者在搜索方法返回后构建包含要打印的节点的列表

修改：如果需要到root的路径节点，则一个简单的布尔返回就足够了：

private boolean trace(Node parent, Node node) { boolean found = (node.data == parent.data) if (!found && parent.left != null) { found = trace(parent.left, node); } if (!found && parent.right != null){ found = trace(parent.right, node); } if (found) { System.out.println(parent.data); } return found; }

如果需要从根到节点的路径，可以传递List以按顺序接收节点：

private boolean trace(Node parent, Node node, List path) { boolean found = (node.data == parent.data) if (!found && parent.left != null) { found = trace(parent.left, node); } if (!found && parent.right != null){ found = trace(parent.right, node); } if (found) { path.add(0, parent); } return found; }

或者你可以在回来的路上建立路径并以列表的形式返回。

private List trace(Node parent, Node node) { List path = null; if (null != node) { if (node.data == parent.data) { path = new ArrayList(); } else { path = trace(parent.left, node); if (null == path) { path = trace(parent.right, node); } } if (null != path) { path.add(0, parent); } } return path; }

Answer 3

这样的东西？

public Stack<Node> findPath(Node src, Node dest, Stack<Node> alreadyCollected) {
    if (src == dest) 
        return alreadyCollected;
    if (src.left == null && src.right == null)
        return null;
    if (src.left != null) {
        Stack<Node> toTheLeft = new Stack<Node>(alreadyCollected);
        toTheLeft.push(src.left);
        Stack<Node> result = findPath(src.left, dest, toTheLeft);
        if (result != null)
            return result;
    }
    List<Node> toTheRight = new Stack<Node>(alreadyCollected);
    return findPath(src.right, dest, toTheRight);
}

Answer 4

这是一个没有使用堆栈的递归函数。递归相当于堆栈技术，并且在进行重新计算时不需要堆栈。

PS：我正在写一个伪代码。自己重写以编译它：）

bool trace(Node curr, Node n, Path path){
    if(curr == null)
        return;
    if(n == curr){
        path.insertAtEnd(curr);
        return true;
    }

    if(trace(curr.left, n, path)){
        path.insertAtEnd(curr);
        return true;
    }
    if(trace(curr.right, n, path)){
        path.insertAtEnd(curr);
        return true;
    }
    return false
}

Answer 5

从trace返回一个布尔值，并决定是否继续根据递归调用返回的值进行搜索。

从递归方法返回时需要帮助

5 个答案: