Question

这是我的Node类：

private class Node {
    private int key;         // the key field
    private Object data;     // the rest of the data item
    private Node left;       // reference to the left child/subtree
    private Node right;      // reference to the right child/subtree
    private Node parent;     // reference to the parent

..等等。

这是具有next（）和hasNext（）方法的inorder迭代器：

private class inorderIterator implements LinkedTreeIterator {

    private Node nextNode;

    private inorderIterator() {
        // The traversal starts with the root node.
        nextNode = root;
        if(nextNode == null)
           return;
        while (nextNode.left != null)
           nextNode = nextNode.left;
    }

    public boolean hasNext() {
        return (nextNode != null);
    }

    public int next() {
        if(!hasNext()) 
            throw new NoSuchElementException();             

        Node r = nextNode;

        if (nextNode.right != null) {
            nextNode = nextNode.right;

            while (nextNode.left != null) {
                nextNode = nextNode.left;
            }

            return r.key;
        } else while (true) {
            if (nextNode.parent == null) {
                nextNode = null;
                return r.key;
            }

            if (nextNode.parent.left == nextNode) {          
                nextNode = nextNode.parent;
                return r.key;    
            }

            nextNode = nextNode.parent;                   
        }            
        return r.key; 
    }
}

问题是，它只打印左侧子树上的左侧节点。例如，对于具有根节点17，左节点15和右节点19的树，它仅打印15 所以它永远不会进入正确的子树。

我猜这个问题与else while (true)部分有关，但我无法弄清楚如何解决这个问题。

Answer 1

您可以尝试递归方式。

类似的东西：

public void printTreeInOrder(Node node){
   if(node.left != null){
      printTree(node.left);
   }
   System.out.println(node.key);
   if(node.right != null){
      printTree(node.right);
   } 
}

如果您传递此方法的根节点，它应该打印出整个树。

我希望这会有所帮助。

最佳。

Answer 2

原来我的节点的父字段没有正确更新。一旦修复，迭代器就能正常工作。

Answer 3

我会使用这个辅助方法的堆栈：

Node advance_to_min(Node r)
  {
    while (r.left != null)
      {
        s.push(r);
        r = r.left;
      }
    return r;
  }

第一个节点是通过在root上调用此方法给出的。类似的东西：

curr = advance_to_min(curr);

然后我会实现next()因此：

void next()
  {
    curr = curr.right;
    if (curr != null)
      {
        curr = advance_to_min(curr);
        return;
      }

    if (s.is_empty())
      curr = null;
    else
      curr = s.pop();
  }

curr并且堆栈s将是迭代器属性。 curr将指向顺序序列中的当前节点。

每个O(lg n)调用最坏情况下的成本next()（如果树趋于平衡）并且该方法不需要父指针;因此，它将具有与使用父指针相同的空间成本，但仅在最坏的情况下

inorder iterator for binary tree - java

3 个答案: