Pregunta de entrevista 54: El k-ésimo nodo más grande de un árbol de búsqueda binario (C ++)

Dirección del título: https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/

Descripción del título

Dado un árbol de búsqueda binario, encuentre el k-ésimo nodo más grande.

Preguntas de ejemplo

Ejemplo 1:

Entrada: raíz = [3,1,4, nulo, 2], k = 1
3
/ \
1 4
\
  2
Salida: 4
Ejemplo 2:

Entrada:. La raíz = [5,3,6,2,4, null, null ,. 1], K = 3
. 5
/ \
. 3. 6
/ \
2 4
/
. 1
de salida: 4

Ideas para resolver problemas

Fuente de la imagen ( https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/solution/mian-shi-ti-54-er-cha -sou-suo-shu-de-di-k-da-jie-d / )

Analizando el problema, podemos encontrar que el recorrido de orden medio del árbol de búsqueda binario (subárbol izquierdo, nodo raíz, subárbol derecho) es una secuencia monotónicamente creciente . Encontrar el kth nodo más grande del árbol de búsqueda binario es equivalente a encontrar el árbol de búsqueda binario El nodo k-ésimo en el orden inverso del recorrido de orden medio , y el recorrido de orden inverso del árbol de búsqueda binario (subárbol derecho, nodo raíz, subárbol izquierdo) es una secuencia monotónicamente decreciente . Debido a que el problema se conoce como árbol de búsqueda binario, se ordena de manera predeterminada ¿Si se requiere el k-ésimo nodo más grande del árbol binario? Entonces, ¿cómo hacerlo? La forma habitual es utilizar el orden del recorrido en el árbol binario, almacenar los valores recorridos en la matriz y luego generar el penúltimo elemento k. Por supuesto, hay otro método clásico que utiliza colas prioritarias para implementar montones superiores grandes y pequeños.

La cola de prioridad se establece de manera predeterminada en un montón superior grande, que cumple con los requisitos del tema, por lo que utilizamos el método de búsqueda de profundidad primero para agregar los valores de todos los nodos en el árbol a la cola de prioridad (montón superior grande predeterminado), y luego aparece los primeros elementos k-1 en la cola de prioridad Y, finalmente, se evalúa el elemento principal.

Código fuente del programa

Recursivo

/ * * 
 * Definición para un nodo de árbol binario. 
 * struct TreeNode { 
 * int val; 
 * TreeNode * izquierda; 
 * TreeNode * correcto; 
 * TreeNode (int x): val (x), izquierda (NULL), derecha (NULL) {} 
 *}; 
 * / 
class Solution {
 public :
     int cnt = 0 ;
    int res_num = 0 ;
    int kthLargest (TreeNode * root, int k) { 
        dfs (root, k); 
        return res_num; 
    } 
    Void DFS (TreeNode * raíz, int k) 
    { 
        si(root == nullptr) return ; 
        dfs (raíz -> derecha, k); 
        cnt ++ ;
        if (cnt == k) 
        res_num = root- > val; 
        dfs (raíz -> izquierda, k); 


    } 
};

Iteración (pila)

/ * * 
 * Definición para un nodo de árbol binario. 
 * struct TreeNode { 
 * int val; 
 * TreeNode * izquierda; 
 * TreeNode * correcto; 
 * TreeNode (int x): val (x), izquierda (NULL), derecha (NULL) {} 
 *}; 
 * / 
class Solution {
 public :
     int cnt = 0 ; // 维护 一个 计数器
     int kthLargest (TreeNode * root, int k) {
         if (root == nullptr) return  0 ; 
        TreeNode * p = raíz; 
        apilar <TreeNode *> s; 
        s.push (p); 
        mientras(p ||! s.empty ()) 
        { 
            while (p) 
            { 
                s.push (p); 
                p = p-> derecha; 
            } 
            p = s.top (); 
            s.pop (); 
            cnt ++ ;
            if (cnt == k) devuelve p-> val; 
            p = p-> izquierda; 
        } 
        devuelve  0 ; 
    } 
};

Montón superior grande (cola prioritaria)

/ * * 
 * Definición para un nodo de árbol binario. 
 * struct TreeNode { 
 * int val; 
 * TreeNode * izquierda; 
 * TreeNode * correcto; 
 * TreeNode (int x): val (x), izquierda (NULL), derecha (NULL) {} 
 *}; 
 * / 
class Solution {
 public : 
    priority_queue < int > prior_que;
    dfs vacío (TreeNode * root) 
    { 
        prior_que.push (root -> val);
        if (root-> left! = nullptr) dfs (root-> left);
        if (root-> right! = nullptr) dfs (root-> right); 
    } 
    intkthLargest (TreeNode * root, int k) { 
        dfs (root); 
        while (- k) 
        { 
            prior_que.pop (); 
        } 
        return prior_que.top (); 
};

Árbol binario para encontrar el k-ésimo nodo más grande en el penúltimo (árbol de búsqueda no binario, es decir, no ordenado)

/ * * 
 * Definición para un nodo de árbol binario. 
 * struct TreeNode { 
 * int val; 
 * TreeNode * izquierda; 
 * TreeNode * correcto; 
 * TreeNode (int x): val (x), izquierda (NULL), derecha (NULL) {} 
 *}; 
 * / 
class Solution {
 public :
     int kthLargest (TreeNode * root, int k) { 
    
     vector < int > res; 
     apilar <TreeNode *> s; 
     TreeNode * p; 
     p = raíz;
     while (p! = NULL ||! s.empty ()) 
     {
         while (p! = NULL) 
         { 
             s.push (p); 
             p = p-> izquierda; 
         } 
         if (! s.empty ()) 
         { 
             p = s.top (); 
             s.pop (); 
             res.push_back (p -> val); 
             p = p-> derecha; 
         } 
     } 
     return res [res.size () - k]; 
    } 
};