Implementación de un iterador sobre un árbol de búsqueda binario

Como TokenMacGuy mencionó, puede usar una pila almacenada en el iterador. Aquí hay una implementación rápida probada de esto en Java:

/**
 * An iterator that iterates through a tree using in-order tree traversal
 * allowing a sorted sequence.
 *
 */
public class Iterator {

    private Stack<Node> stack = new Stack<>();
    private Node current;

    private Iterator(Node argRoot) {
        current = argRoot;
    }

    public Node next() {
        while (current != null) {
            stack.push(current);
            current = current.left;
        }

        current = stack.pop();
        Node node = current;
        current = current.right;

        return node;
    }

    public boolean hasNext() {
        return (!stack.isEmpty() || current != null);
    }

    public static Iterator iterator(Node root) {
        return new Iterator(root);
    }
}

Otra variación sería atravesar el árbol en el tiempo de construcción y guardar el recorrido en una lista. Puede usar el iterador de lista después.

Ok, sé que esto es viejo, pero me preguntaron esto en una entrevista con Microsoft hace un tiempo y decidí trabajar en ello un poco. He probado esto y funciona bastante bien.

template <typename E>
class BSTIterator
{  
  BSTNode<E> * m_curNode;
  std::stack<BSTNode<E>*> m_recurseIter;

public:
    BSTIterator( BSTNode<E> * binTree )
    {       
        BSTNode<E>* root = binTree;

        while(root != NULL)
        {
            m_recurseIter.push(root);
            root = root->GetLeft();
        }

        if(m_recurseIter.size() > 0)
        {
            m_curNode = m_recurseIter.top();
            m_recurseIter.pop();
        }
        else
            m_curNode = NULL;
    }

    BSTNode<E> & operator*() { return *m_curNode; }

    bool operator==(const BSTIterator<E>& other)
    {
        return m_curNode == other.m_curNode;
    }

    bool operator!=(const BSTIterator<E>& other)
    {
        return !(*this == other);
    }

    BSTIterator<E> & operator++() 
    { 
        if(m_curNode->GetRight())
        {
            m_recurseIter.push(m_curNode->GetRight());

            if(m_curNode->GetRight()->GetLeft())
                m_recurseIter.push(m_curNode->GetRight()->GetLeft());
        }

        if( m_recurseIter.size() == 0)
        {
            m_curNode = NULL;
            return *this;
        }       

        m_curNode = m_recurseIter.top();
        m_recurseIter.pop();

        return *this;       
    }

    BSTIterator<E> operator++ ( int )
    {
        BSTIterator<E> cpy = *this;     

        if(m_curNode->GetRight())
        {
            m_recurseIter.push(m_curNode->GetRight());

            if(m_curNode->GetRight()->GetLeft())
                m_recurseIter.push(m_curNode->GetRight()->GetLeft());
        }

        if( m_recurseIter.size() == 0)
        {
            m_curNode = NULL;
            return *this;
        }       

        m_curNode = m_recurseIter.top();
        m_recurseIter.pop();

        return cpy;
    }

};

Tree traversal , de Wikipedia:

Todas las implementaciones de ejemplo requerirán un espacio de pila de llamadas proporcional a la altura del árbol. En un árbol mal equilibrado, esto puede ser bastante considerable.

Podemos eliminar el requisito de pila manteniendo los punteros padre en cada nodo, o enhebrando el árbol. En el caso de usar subprocesos, esto permitirá un recorrido de orden mucho mejor, aunque recuperando el nodo padre requerido para el preorden y postorder traversal será más lento que un simple algoritmo basado en pila.

En el artículo hay algún pseudocódigo para iteración con estado O(1), que se puede adaptar fácilmente a un iterador.

Qué tal usar una técnica de búsqueda de profundidad primero. El objeto iterador solo debe tener una pila de los nodos ya visitados.

Si usas stack, solo alcanzas "Uso Extra de memoria O(h), h es la altura del árbol". Sin embargo, si desea utilizar solo O(1) memoria adicional, debe grabar el Aquí están los análisis: - Si el nodo actual tiene el hijo correcto: buscar min del sub árbol correcto - El nodo actual no tiene un hijo correcto, debe buscarlo desde la raíz y seguir actualizando su ancestro más bajo, que es su siguiente nodo más bajo

public class Solution {
           //@param root: The root of binary tree.

           TreeNode current;
           TreeNode root;
           TreeNode rightMost;
           public Solution(TreeNode root) {

               if(root==null) return;
                this.root = root;
                current = findMin(root);
                rightMost = findMax(root);
           }

           //@return: True if there has next node, or false
           public boolean hasNext() {

           if(current!=null && rightMost!=null && current.val<=rightMost.val)    return true; 
        else return false;
           }
           //O(1) memory.
           public TreeNode next() {
                //1. if current has right child: find min of right sub tree
                TreeNode tep = current;
                current = updateNext();
                return tep;
            }
            public TreeNode updateNext(){
                if(!hasNext()) return null;
                 if(current.right!=null) return findMin(current.right);
                //2. current has no right child
                //if cur < root , go left; otherwise, go right

                    int curVal = current.val;
                    TreeNode post = null;
                    TreeNode tepRoot = root;
                    while(tepRoot!=null){
                      if(curVal<tepRoot.val){
                          post = tepRoot;
                          tepRoot = tepRoot.left;
                      }else if(curVal>tepRoot.val){
                          tepRoot = tepRoot.right;
                      }else {
                          current = post;
                          break;
                      }
                    }
                    return post;

            }

           public TreeNode findMin(TreeNode node){
               while(node.left!=null){
                   node = node.left;
               }
               return node;
           }

            public TreeNode findMax(TreeNode node){
               while(node.right!=null){
                   node = node.right;
               }
               return node;
           }
       }

Use espacio O(1), lo que significa que no usaremos pila O(h).

Para comenzar:

1. HasNext ()? actual.val

2. Buscar min vía left-most: Siempre podemos buscar left-most para encontrar el siguiente valor mínimo.

3. Una vez más a la izquierda se marca min (nombre current). El próximo minuto serán 2 casos: Si es actual.¡Vale!= null, podemos seguir buscando current.la derecha es el niño más izquierdo, como el próximo minuto. O, necesitamos mira hacia atrás para los padres. Utilice el árbol de búsqueda binario para encontrar el nodo padre de current.

Nota : al hacer la búsqueda binaria para padre, asegúrese de que satisface padre.izquierda = corriente.

Porque:Si padre.derecha = = actual, ese padre debe haber sido visitado antes. En el árbol de búsqueda binario, conocemos a ese padre.val

public class BSTIterator {
    public TreeNode root;
    public TreeNode current;
    public TreeNode endNode;
    //@param root: The root of binary tree.
    public BSTIterator(TreeNode root) {
        if (root == null) {
            return;
        }
        this.root = root;
        this.current = root;
        this.endNode = root;

        while (endNode != null && endNode.right != null) {
            endNode = endNode.right;
        }
        while (current != null && current.left != null) {
            current = current.left;
        }
    }

    //@return: True if there has next node, or false
    public boolean hasNext() {
        return current != null && current.val <= endNode.val;
    }

    //@return: return next node
    public TreeNode next() {
        TreeNode rst = current;
        //current node has right child
        if (current.right != null) {
            current = current.right;
            while (current.left != null) {
                current = current.left;
            }
        } else {//Current node does not have right child.
            current = findParent();
        }
        return rst;
    }

    //Find current's parent, where parent.left == current.
    public TreeNode findParent(){
        TreeNode node = root;
        TreeNode parent = null;
        int val = current.val;
        if (val == endNode.val) {
            return null;
        }
        while (node != null) {
            if (val < node.val) {
                parent = node;
                node = node.left;
            } else if (val > node.val) {
                node = node.right;
            } else {//node.val == current.val
                break;
            }
        }
        return parent;
    }
}

Por definición, no es posible que next() y hasNext() se ejecuten en tiempo O(1). Cuando está mirando un nodo en particular en un BST, no tiene idea de la altura y la estructura de los otros nodos, por lo tanto, no puede simplemente "saltar" al siguiente nodo correcto.

Sin embargo, la complejidad del espacio se puede reducir a O(1) (excepto para la memoria de la propia BST). Esta es la forma en que lo haría en C:

struct node{
    int value;
    struct node *left, *right, *parent;
    int visited;
};

struct node* iter_next(struct node* node){
    struct node* rightResult = NULL;

    if(node==NULL)
        return NULL;

    while(node->left && !(node->left->visited))
        node = node->left;

    if(!(node->visited))
        return node;

    //move right
    rightResult = iter_next(node->right);

    if(rightResult)
        return rightResult;

    while(node && node->visited)
        node = node->parent;

    return node;
}

El truco es tener un enlace padre y una bandera visitada para cada uno nodo. En mi opinión, podemos argumentar que esto no es un uso de espacio adicional, es simplemente parte de la estructura del nodo. Y obviamente, iter_next () debe ser llamada sin que cambie el estado de la estructura del árbol (por supuesto), pero también que las banderas "visitadas" no cambien los valores.

Aquí está la función tester que llama a iter_next() e imprime el valor cada vez para este árbol:

                  27
               /      \
              20      62
             /  \    /  \
            15  25  40  71
             \  /
             16 21

int main(){

    //right root subtree
    struct node node40 = {40, NULL, NULL, NULL, 0};
    struct node node71 = {71, NULL, NULL, NULL, 0};
    struct node node62 = {62, &node40, &node71, NULL, 0};

    //left root subtree
    struct node node16 = {16, NULL, NULL, NULL, 0};
    struct node node21 = {21, NULL, NULL, NULL, 0};
    struct node node15 = {15, NULL, &node16, NULL, 0};
    struct node node25 = {25, &node21, NULL, NULL, 0};
    struct node node20 = {20, &node15, &node25, NULL, 0};

    //root
    struct node node27 = {27, &node20, &node62, NULL, 0};

    //set parents
    node16.parent = &node15;
    node21.parent = &node25;
    node15.parent = &node20;
    node25.parent = &node20;
    node20.parent = &node27;
    node40.parent = &node62;
    node71.parent = &node62;
    node62.parent = &node27;

    struct node *iter_node = &node27;

    while((iter_node = iter_next(iter_node)) != NULL){
        printf("%d ", iter_node->value);
        iter_node->visited = 1;
    }
    printf("\n");
    return 1;
}

Que imprimirá los valores en orden:

15 16 20 21 25 27 40 62 71