p62 reciente ancestro común binario de nodos (leetcode 236)

A: las ideas de resolución de problemas

Después de la trayectoria de corriente desde el nodo raíz a nodo de la matriz p ppath para grabar, ficha desde el nodo raíz al nodo q través de abajo actual a qpath, el contraste de estos dos nodos que pasado la misma matriz, y devolverlo a. Tiempo: O (n), el espacio: O (n)

Dos: ejemplos de código completo (C ++ versión y la versión Java)

C ++:

clase de soluciones 
{ 
público :
     int min ( int a, int b) { volver a <b? a: b; } 

    Bool buscar (TreeNode * raíz, TreeNode * nodo, vector <TreeNode *> & ruta) 
    { 
        si (raíz == NULL) de retorno  falsa ; 
        path.push_back (raíz); 
        si (== raíz nodo) volver  verdadera ;
        bool ret = buscar (Raíz> izquierda, nodo, ruta) || buscar (Raíz> derecha, nodo, ruta);
        si (RET) de retorno RET; 
        path.pop_back ();
        volver  falsa ; 
    } 

    TreeNode * ancestro común más bajo (TreeNode * raíz, TreeNode * p, TreeNode * q) 
    { 
        vector <TreeNode *> ppath; 
        vector <TreeNode *> qpath; 

        buscar (raíz, p, ppath); 
        buscar (raíz, q, qpath); 

        int i = 0 , len = min (ppath.size (), qpath.size ()); 

        mientras que (i <len && ppath [i] == qpath [i]) i ++ ; 

        retorno qpath [i- 1 ]; 
    } 
};

Java:

clase de soluciones {
     privada búsqueda booleana (raíz TreeNode, nodo TreeNode, List <TreeNode> ruta) 
    { 
        si (raíz == nula ) de retorno  falsa ; 
        path.add (raíz); 
        si (== raíz nodo) volver  verdadera ; 
        boolean ret = buscar (root.left, nodo, ruta) || buscar (root.right, nodo, ruta de acceso);
        si (RET) volver  verdadero ; 
        path.remove (path.size () - 1 );
        volver  falsa ; 
    } 
    
    públicaNodoArbol ancestro común más bajo (raíz TreeNode, NodoArbol p, q NodoArbol) 
    { 
        Lista <TreeNode> ppath = nuevo ArrayList <> (); 
        Lista <TreeNode> qpath = nuevo ArrayList <> (); 
        
        buscar (raíz, p, ppath); 
        buscar (raíz, q, qpath); 
        
        int i = 0 , len = Math.min (ppath.size (), qpath.size ());
        mientras que (i <len && ppath. obtener (i) == qpath. consigo (i)) i ++ ; 
        
        volver ppath. obtener (i- 1 ); 
    } 
}