迭代逆序遍历

Question

I'd like to find the item that layout places directly above an element. In the DOM structure of the page, this means that something could be nested a few levels deep, or it could also mean stepping up a few levels in the hierarchy. For example

div.a        
  div.b      
    div.c      
    div.d    
      div.e  
        div.f
    div.g    
  div.h      
  div.i      
div.j        
div.k        

Where .b, .h, .i are immediate children of .a , and so on.

For example when I call getBefore($('.h')); I expect to fetch .g . This would ostensibly involve a preorder reverse search that hits div.b first.

The problem that I'm having is that without performing a global recursive scan, it's difficult to deal with the case of getBefore($('.c')); where I am expecting to get .b because it is the item that lies before it in the layout. The routine, not having a global traversal recursion stack to know any better, would look at .b (unaware that .d was a middle child and that it should not recurse down) and fetch the bottom-most item in its hierarchy which turns out to be .g , taking us in the wrong direction.

So based on this observation it seems to me like a recursive implementation can't be done cleanly, as the input to the routine is not the root node but some node inside of some tree whose structure is not known. What, then, is a reasonable way to implement this iteratively? The DOM gives me pointers to move up to the parent node, and i also have pointers to the previous node, if any, and I can also fetch the list of children of any given mode, if any.

Answer 1

This is how I got it to work. It uses a combination of a regular recursive preorder traversal routine which is called by an iterative routine that is aware of which direction to go.

The iterative routine takes a node, and walks up the sibling list by calling node = node.previousSibling . When it reaches the top it goes to the parent: node = node.parentNode . At every step it will call a method that uses standard recursive preorder search which fetches the last suitable item in the tree rooted by the node. This way .g leads to .f because $('.g')[0].previousSibling is .d and .d 's last item is .f .

Strangely enough, moving forward, the getAfter() routine which does the same, but goes in the forward direction, does not require recursion. Doing it recursively does make for slightly more elegant code though.

Answer 2

Key idea of preorder traversal using stack is to push right child and then left child so that left child will be processed before right child.

class Node {
    int key;
    Node left, right;

    public Node() {}

    public Node(int key) {
        this.key = key;
    }
}

public List<Integer> preOrderIterative() {
    List<Integer> list = new ArrayList<>();
    Stack<Node> nodeStack = new Stack<>();

    nodeStack.push(root);

    while (!nodeStack.empty()) {
         Node node = nodeStack.pop();
         list.add(node.key);

         if (null != node.right) nodeStack.push(node.right);
         if (null != node.left) nodeStack.push(node.left);
    }
    return list;
}