Java 递归遍历树的深度优先问题

我正在尝试使用ANTLR-tree命令和递归遍历一棵树。我目前拥有的代码是：

public void traverseTree(Tree tree){
        int counter = 0;
        System.out.println(tree.toString());
        if (tree.getChildCount() > 0 && tree.getChild(0) != null){
            System.out.println(tree.toString() + counter++);
            tree = tree.getChild(0);
            traverseTree(tree);

        }
        while (tree.getParent().getChild(tree.getChildIndex() + 1) != null){
            System.out.println(tree.toString() + counter++);
            tree = tree.getParent().getChild(tree.getChildIndex() + 1);
            traverseTree(tree);

        }
    }

但是，它不起作用。我在树中得到了很多条目，但并没有明显的顺序。有人能看出我哪里做错了吗

谢谢

编辑：

我在下面所作的评论本应在这里开始：

---

对不起，我应该删除打印语句，它们只是用来调试的。我遇到的问题是，它应该只搜索它启动的节点和该节点的任何兄弟节点，它不应该上升一个级别，但它会，它会打印所有内容。（我将把它编辑到主目录中，它本来应该在那里，对不起）

我最终设法让代码像这样工作：

public void traverseTree(Tree tree){
        System.out.println(tree);
        if (tree.getChild(0) != null){
            traverseTree(tree.getChild(0));
        }
        if(tree.getParent().getChildCount() > 1){
            if(tree.getParent().getChild(tree.getChildIndex() + 1) != null)
            traverseTree(tree.getParent().getChild(tree.getChildIndex() + 1));
        }
    }

试试这个：

int counter = 0;
public void traverseTree(Tree tree) {

    for (int i=0; i<tree.getChildCount(); i++) {
        Tree child = tree.getChild(i);
        System.out.println(tree.toString() + counter++);
        traverseTree(tree);
    }
}

int计数器=0；
公共void遍历树（树）{
对于（int i=0；i请尝试以下方法：

int counter = 0;
public void traverseTree(Tree tree) {

    for (int i=0; i<tree.getChildCount(); i++) {
        Tree child = tree.getChild(i);
        System.out.println(tree.toString() + counter++);
        traverseTree(tree);
    }
}

int计数器=0；
公共void遍历树（树）{
对于（int i=0；i而言，看起来您要多次打印相同的节点。如果您只想在下一步打印节点

   1
 2   3
4 5   6

Depth first - 1 2 4 5 3 6
Breadth first - 1 2 3 4 5 6

//For depth first
public void traverseTree(Tree tree){        
    System.out.println(tree.toString());
    for (int x = 0; x < tree.getChildCount(); x++)
        traverseTree(tree.getChild(x));
}

1
2   3
4 5   6
深度优先-1 2 4 5 3 6
广度优先-123456
//深度优先
公共void遍历树（树）{
System.out.println（tree.toString（））；
对于（int x=0；x

要切换到4 5 6 2 3 1，只需在for循环之后将println移动到。
看起来您正在多次打印相同的节点。如果您只想在下一步打印节点

   1
 2   3
4 5   6

Depth first - 1 2 4 5 3 6
Breadth first - 1 2 3 4 5 6

//For depth first
public void traverseTree(Tree tree){        
    System.out.println(tree.toString());
    for (int x = 0; x < tree.getChildCount(); x++)
        traverseTree(tree.getChild(x));
}

1
2   3
4 5   6
深度优先-1 2 4 5 3 6
广度优先-123456
//深度优先
公共void遍历树（树）{
System.out.println（tree.toString（））；
对于（int x=0；x

要切换到4 5 6 2 3 1，只需将println移动到for循环之后。
确保它永远不会上升一个级别的最简单方法是确保您永远不会调用
getParent（）
。如果您不知道有更高的级别，您就不能去那里

public void traverseTree(Tree tree) {

    // print, increment counter, whatever
    System.out.println(tree.toString());

    // traverse children
    int childCount = tree.getChildCount();
    if (childCount == 0) {
        // leaf node, we're done
    } else {
        for (int i = 0; i < childCount; i++) {
            Tree child = tree.getChild(i);
            traverseTree(child);
        }
    }
}

公共void遍历树（树）{
//打印，增量计数器，随便什么
System.out.println（tree.toString（））；
//遍历儿童
int childCount=tree.getChildCount（）；
if（childCount==0）{
//叶节点，我们完成了
}否则{
for（int i=0；i

递归的全部要点是不需要返回。当此级别的
traverseTree（）
完成时，上一级别的循环将继续到下一个同级

（请注意，
if
实际上并不是必需的，除非您在到达叶节点时想做一些特殊的事情。我只是把它放在那里，以便注释能够清楚地说明发生了什么。从概念上讲，在递归中，从弄清楚如何知道何时停止递归开始总是一个好主意。）
确保它永远不会提升级别的最简单方法是确保您永远不会调用
getParent（）
。如果您不知道有更高级别，您就不能去那里

public void traverseTree(Tree tree) {

    // print, increment counter, whatever
    System.out.println(tree.toString());

    // traverse children
    int childCount = tree.getChildCount();
    if (childCount == 0) {
        // leaf node, we're done
    } else {
        for (int i = 0; i < childCount; i++) {
            Tree child = tree.getChild(i);
            traverseTree(child);
        }
    }
}

公共void遍历树（树）{
//打印，增量计数器，随便什么
System.out.println（tree.toString（））；
//遍历儿童
int childCount=tree.getChildCount（）；
if（childCount==0）{
//叶节点，我们完成了
}否则{
for（int i=0；i

递归的全部要点是不需要返回。当此级别的
traverseTree（）
完成时，上一级别的循环将继续到下一个同级

（请注意，
if
实际上并不是必需的，除非您在到达叶节点时想做一些特殊的事情。我只是把它放在那里，以便注释能够清楚地说明发生了什么。从概念上讲，在递归中，最好先弄清楚如何知道何时停止递归。）
“深度优先”…你是说水平顺序？反向水平顺序？我很困惑..其他可能是“深度优先”的前顺序、顺序、后顺序…你的意思是级别顺序？反向级别顺序？我很困惑..其他可能是前序、中序、后序抱歉，我应该删除打印语句，它们只是在那里尝试调试它。我遇到的问题是，它应该只搜索它启动的节点和该节点的任何同级，它不应该上升一个级别，但是它会打印所有内容。（我会将其编辑到main中，很抱歉，它本来应该在那里。）@Incredidave-Thomas的解决方案（几乎）可以在您给它的任何节点上工作（它应该有空的退出语句）。如果要从一个子节点开始，只需传递该子节点，而不是根节点。您确实需要更具体地说明如何访问每个节点，打算在那里执行什么操作，以及顺序。我假设子节点不为null，因此它将因getChildCount（）而终止为0。在任何情况下，它都不能回答实际问题。抱歉，我应该删除打印语句，它们只是在那里尝试并调试它。我遇到的问题是，它应该只搜索它启动的节点和该节点的任何同级，它不应该上升一个级别，但它会打印所有内容。（我将把它编辑到main中，它本来应该在那里的，对不起）。@Incredidave-Thomas的解决方案（几乎）在你给它的任何节点上都有效（它应该有空的退出语句）。如果您想从一个子节点开始，只需传递该子节点，而不是根节点。您确实需要更具体地说明如何访问每个节点，打算在那里执行什么操作，以及顺序。我假设子节点不为null，所以