N-ary Trees non-recursive traversal algorithms

Question

Hi,
Non-recursive traversals are needed when you are unsure how big the tree's will be. So far all the algorithms I have seen either use their own internal stack
or threading to climb back up the tree.
Here's my attempt that seems to work but I would value so critical evaluation
* An extension of the CommonAST that records the line and column
* number.  The idea was taken from <a target="_top"
* href="http://www.jguru.com/jguru/faq/view.jsp?EID=62654">Java Guru
* FAQ: How can I include line numbers in automatically generated
* ASTs?</a>.
* @author Oliver Burn
* @author lkuehne
* @version 1.0
* @see <a target="_top" href="http://www.antlr.org/">ANTLR Website</a>
public class DetailAST
    public AST getFirstChild()
    public AST getNextSibling()
    public int getChildCount()
    public DetailAST getParent()
    public int getChildCount(int aType)
    public String getText()
}This was cut back just to give you enough info
     public static AST getLeftMostChild(DetailAST ast) {
          DetailAST tempAst = ast.getFirstChild();
          while (tempAst.getFirstChild() != null) {
               tempAst = tempAst.getFirstChild();
          return tempAst;
     public static void traverseASTInOrder(DetailAST root) {
          DetailAST current = getLeftMostChild(ast);
          processNode(current);
          while (current != root) {
               if (current == current.getParent().getFirstChild()) {
                    processNode(current.getParent());
               if (current.getNextSibling() != null) {
                    DetailAST sibling = current.getNextSibling();
                    if (sibling.getChildCount() != 0) {
                         current = (DetailAST) getLeftMostChild(sibling);
                         processNode(current);
                    } else {
                         current = sibling;
                         processNode(current);
               } else {
                    current = current.getParent();
        // do stuff at inorder traversal
     public static void processNode(AST current) {
          System.out.println(current.getText());
     }for pre-order and post-order John Cowan put forward this algorithm
http://lists.xml.org/archives/xml-dev/199811/msg00050.html
traverse(Node node) {
    Node currentNode = node;
    while (currentNode != null) {
      visit(currentNode); //pre order
      // Move down to first child
      Node nextNode = currentNode.getFirstChild();
      if (nextNode != null) {
        currentNode = nextNode;
        continue;
      // No child nodes, so walk tree
      while (currentNode != null) {
        revisit(currentNode)     // post order
        // Move to sibling if possible.
        nextNode = currentNode.getNextSibling();
        if (nextNode != null) {
          currentNode = nextNode;
          break;
       // Move up
       if (currentNode = node)
      currentNode = null;
       else
      currentNode = currentNode.getParentNode();
  }Any comments, criticisms or suggestions ?
regards
David Scurrah

Answer 1

Stack is recursion? As far as I know recursion is when
function (method) calls itself. Just using some
Collection, which java.util.Stack implements is not
recursion.
Regards
PawelStacks are used to implement recursive algorithms. What happens in most languages when you make a function call? Each function has an "activation record" where it stores its local variables and parameters. This activation record is usually allocated on a stack. Thus for any recursive algorithm, there is a non-recursive algorithm that uses a stack.
In the OP's case you don't need a stack because of the peculiarities of tree traversal when you have a pointer to the parent node. (Namely, no cycles and you can get back to where you've been) So the algorithms he gave should work fine.
My only "criticism" would be that it may be more useful to implement these algorithms with the iterator pattern. So you would have a tree with some functions like:
public class Tree{
    public TreeIterator inOrderIteraror();
    public TreeIterator preOrderIterator();
}Where the TreeIterator would look like a java.util.Iterator, except maybe you want some additional utility methods in there or something.
Other than that, non-recursive algorithms are defnitely the way to go.