Modo Likou 501 en el árbol de búsqueda binaria

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

El contenido del tema es el siguiente:

Dado un árbol de búsqueda binaria (BST) con el mismo valor, busque todos los modos (el elemento que ocurre con más frecuencia) en el 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
• Tanto el subárbol izquierdo como el subárbol derecho son árboles de búsqueda binarios

Por ejemplo:
dado BST [1, null, 2,2],

   1
    \
     2
    /
   2
vuelta a [2].

Consejo: si el modo excede 1, no es necesario considerar el orden de salida

Avanzado: ¿No puedes usar espacio extra? (Suponiendo que la sobrecarga de la pila de llamadas implícita generada por la recursividad no se incluye en el cálculo)

 

        Árbol de clasificación binaria, también conocido como árbol de búsqueda binaria, árbol de clasificación binaria, a partir de la estructura de datos y el título podemos saber que todos los nodos del subárbol izquierdo de cualquier nodo son menores o iguales a su valor, y todos los nodos del subárbol derecho son mayores o iguales a su valor. Valor, por supuesto, la propiedad más crítica es que los resultados del recorrido de orden medio del árbol de ordenación binaria están ordenados, los resultados del recorrido de orden medio del árbol de ordenación binaria son ordenados, y se ordenan los resultados del recorrido de orden medio del árbol de ordenación binaria. Por lo tanto, para este problema, después de aplicar esta propiedad, se vuelve fácil de resolver: para encontrar el modo del árbol de ordenamiento binario, se puede simplificar atravesar el resultado de su orden, como [1,2,3,3, 3, 4, 4, 7], es decir, la posición donde aparece cada número es continua, y el número con más ocurrencias consecutivas se coloca en el resultado final. Obviamente, si no se considera el espacio extra, entonces se puede usar el método recursivo o no recursivo de recorrido en orden para guardar el resultado (valor del nodo raíz) de cada salida en una estructura de datos como una matriz o cola, y luego atravesar a su vez para obtener.

        Pero el requisito avanzado es que no se usa espacio adicional, pero la recursividad aún se puede usar, por lo que se puede juzgar dinámicamente en lugar de mantener todos los resultados de salida:

        Establezca las variables Res, MaxNum, CurNum y CurVal utilizadas para guardar resultados temporales, es decir, de la siguiente manera. (La idea del título no indica claramente el tamaño del valor del nodo, el valor predeterminado es int)

nombre de la variable	Tipos de	Paráfrasis
Res	vector <int>	Guardar todos los modos actuales
maxNum	En t	El número de ocurrencias del modo correspondiente a la actual Res.
curne	En t	El número de apariciones del valor de nodo anterior.
CurVal	En t	Valor de nodo anterior

        Cada vez que el valor del nodo actual se obtiene de forma recursiva, el juicio se realiza en orden:

        1. Si es coherente con el valor del nodo anterior (nodo principal), si es el mismo, entonces el número de apariciones del valor del nodo anterior CurNum aumenta en 1; de lo contrario, actualice CurVal al valor del nodo actual y establezca CurNum en 1.

        2. Si el CurNum actualizado es mayor que MaxNum, si es mayor, Res se borra (ya hay un número con más ocurrencias que el "modo temporal" actual con más ocurrencias, entonces el nuevo número es el "modo temporal" ), y Ponga el CurVal actual en Res, y establezca MaxNum en CurNum; si es igual, significa que el valor del nodo también es el "modo temporal", y ponga el CurVal actual en Res.

        Entonces, hasta el final de la recursividad, el valor contenido en Res es el resultado final.

/**
 * 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> Res;//储存众数
    int MaxNum=0;//Res中储存的最大次数
    int CurNum=0;//上次遍历数字出现次数
    int CurVal=-1;//上次遍历数字
    void LDR(TreeNode* root){
        if(root==NULL){
            return ;
        }
        else{
            LDR(root->left);
            int IterVal=root->val;//本次得到的值
            if (IterVal!=CurVal){//如果本次的值与上一次的值不等
                CurVal=IterVal;//更新
                CurNum=1;

            }
            else{//相等则加一
                CurNum+=1;
                }
            if (CurNum==MaxNum){//次数与最多次数相等，则放入
                Res.push_back(CurVal);
            }
            else if (CurNum>MaxNum){//大于则重置
                Res.clear();
                MaxNum=CurNum;
                Res.push_back(CurVal);
            }

            LDR(root->right);
        }
    }
    vector<int> findMode(TreeNode* root) {
        LDR(root);
        return Res;
    }
};