La implementación de un iterador sobre un árbol de búsqueda binaria

El recorrido del árbol , de Wikipedia:

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

Podemos eliminar el requisito de la pila mediante el mantenimiento de los punteros de padres en cada nodo, o enroscando el árbol. En el caso de usar hilos, esto permitirá mejorado en gran medida a finde traversal, aunque recuperar el nodo padre requerido para preorden y postorden traversal será más lento que un algoritmo basado pila simple.

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

Ok, sé que esto es viejo, pero me preguntaron en una entrevista con Microsoft hace un tiempo y decidí trabajar en él 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;
    }

};

Como se ha mencionado TokenMacGuy puede utilizar una pila almacenada en el repetidor. He aquí una rápida implementación de esta prueba 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 la de recorrer el árbol en el tiempo de construcción y guardar el recorrido en una lista. Se puede utilizar el iterador de la lista después.

¿Qué pasa con el uso de una primera técnica de búsqueda en profundidad. El objeto iterador simplemente debe tener una pila de los nodos ya visitados.

Si utiliza la pila, es lograr "el uso de memoria adicional O (h), h es la altura del árbol". Sin embargo, si desea utilizar solamente O (1) de memoria adicional, es necesario registrar el Éstos son el análisis: - Si el nodo actual tiene hijo derecho: encontrar min de la sub árbol de la derecha - Se nodo actual no tiene hijo derecho, es necesario para buscar desde la raíz, y mantener la actualización de su ancestro más bajo, que es su nivel más bajo siguiente nodo

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;
           }
       }

Utilice O (1) el espacio, lo que significa que no vamos a utilizar O (h) de la pila.

Empezar:

1. hasNext ()? current.val <= endNode.val para comprobar si el árbol está totalmente atravesada.

2. Encuentra min a través de más a la izquierda: Podemos mirar alwasy de valor mínimo al lado izquierdo de encontrar.

3. Una vez más a la izquierda está marcada min (nombrarlo current). Siguiente min será de 2 casos: Si current.right = null, podemos seguir buscando más a la izquierda del niño current.right, como el próximo min!. O bien, tenemos que mirar hacia atrás para padres. Utilice árbol binario de búsqueda para encontrar nodo padre del actual.

Nota : cuando se hace una búsqueda binaria para los padres, asegúrese de que satisface parent.left = corriente.

Debido: Si parent.right == actual, que debe padre ha sido visitado antes. En árbol binario de búsqueda, sabemos que parent.val <parent.right.val. Tenemos que saltar este caso especial, ya que conduce a ifinite bucle.

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 para el próximo () y hasNext () para ejecutar en O (1) tiempo. Cuando usted está buscando en un nodo particular en un BST, no tiene idea de la altura y la estructura de los otros nodos son, por lo tanto, no se puede simplemente "salto" al siguiente nodo correcto.

Sin embargo, la complejidad de espacio se puede reducir a O (1) (a excepción de la memoria para el BST sí mismo). 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 tanto un vínculo padre, y una bandera para cada nodo visitado. En mi opinión, se puede argumentar que este no es el uso de espacio adicional, es simplemente parte de la estructura de nodos. Y, obviamente, iter_next () debe ser llamado sin el estado de la estructura de árbol cambiando (por supuesto), sino también que el "visitada" banderas no cambian los valores.

Esta es la función de probador que iter_next () llama e imprime el valor de cada hora de 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 el orden establecido:

15 16 20 21 25 27 40 62 71