Modo [Árbol de ofertas de dedo de espada] en el árbol de búsqueda binaria

Descripción del título

Dado un árbol de búsqueda binario (BST) con el mismo valor, encuentre todos los modos (elementos con la frecuencia más alta) en BST.
Suponga que BST tiene la siguiente definición:

• El valor del nodo contenido en el subárbol izquierdo del nodo es menor o igual que el valor del nodo actual
• El valor del nodo contenido en el subárbol derecho del nodo es mayor o igual que el valor del nodo actual
• Los subárboles izquierdo y derecho son árboles de búsqueda binarios.

Ejemplos:

例如：
给定 BST [1,null,2,2],
   1
    \
     2
    /
   2
返回[2].

Enlace del título: https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/

Ideas

El árbol de búsqueda binario tiene una propiedad importante: la secuencia transversal de orden medio del árbol de búsqueda binaria es una secuencia ascendente. Por lo tanto, atravesamos la secuencia ascendente de valores de nodo en el árbol de búsqueda binario, y luego encontramos el modo de acuerdo con la secuencia ascendente. La forma de encontrar la mayoría:

• Coloque el primer elemento de la secuencia en el resultado, registre el número máximo de ocurrencias del elemento actual como curMax e inicialícelo en 1, y registre el número de ocurrencias del elemento actual como 1;
• Comience a recorrer desde el segundo elemento, si el elemento actual y el elemento anterior son iguales, entonces cnt ++;
  • Si cnt == curMax, se supone que el elemento actual está en el resultado;
  • Si cnt> curMax, significa que se encuentra un modo con más ocurrencias, el resultado se borra y el elemento actual se agrega al resultado;
• Si el elemento actual no es igual al elemento anterior, establezca cnt en 1.

El código es el siguiente:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        if(root==nullptr) return {};

        vector<int> v;
        inOrder(root, v);
        
        int cnt = 1;
        int curMax = 1;
        vector<int> ans;
        ans.push_back(v[0]);
        for(int i=1; i<v.size(); i++){
            if(v[i]==v[i-1]){
                cnt++;
            }else cnt=1;
            if(cnt==curMax){
                ans.push_back(v[i]);
            }else if(cnt>curMax){
                curMax = cnt;
                ans.clear();
                ans.push_back(v[i]);
            }
        }
        return ans;
    }

    void inOrder(TreeNode* root, vector<int>& v){
        if(root==nullptr) return;

        inOrder(root->left, v);
        v.push_back(root->val);
        inOrder(root->right, v);
    }
    
};

• Complejidad del tiempo: O (h + n)
  h es la profundidad del árbol yn es el número de nodos.
• Complejidad del espacio: O (n)
  n es el número de nodos.