Mode Likou 501 dans l'arborescence de recherche binaire

Lien du titre original: https://leetcode-cn.com/problems/find-mode-in-binary-search-tree

Le contenu du sujet est le suivant:

Étant donné un arbre de recherche binaire (BST) avec la même valeur, trouvez tous les modes (l'élément le plus fréquent) dans le BST.

Supposons que BST a la définition suivante:

• La valeur du nœud contenu dans le sous-arbre gauche du nœud est inférieure ou égale à la valeur du nœud courant
• La valeur du nœud contenu dans le sous-arbre droit du nœud est supérieure ou égale à la valeur du nœud courant
• Le sous-arbre gauche et le sous-arbre droit sont des arbres de recherche binaires

Par exemple:
étant donné BST [1, null, 2,2],

   1
    \
     2
    /
   2
retour à [2].

Astuce: si le mode dépasse 1, pas besoin de prendre en compte l'ordre de sortie

Avancé: ne pouvez-vous pas utiliser d'espace supplémentaire? (En supposant que la surcharge de la pile d'appels implicites générée par récursivité n'est pas incluse dans le calcul)

 

        Arbre de tri binaire, également connu sous le nom d'arbre de recherche binaire, arbre de tri binaire, à partir de la structure de données et du titre, nous pouvons savoir que tous les nœuds du sous-arbre gauche de tout nœud sont inférieurs ou égaux à sa valeur, et tous les nœuds du sous-arbre droit sont supérieurs ou égaux à sa valeur. La valeur, bien sûr, la propriété la plus critique est que les résultats de la traversée d'ordre intermédiaire de l'arbre de tri binaire sont ordonnés, les résultats de la traversée d'ordre intermédiaire de l'arbre de tri binaire sont ordonné, et les résultats de la traversée d'ordre intermédiaire de l'arbre de tri binaire sont ordonnés. Par conséquent, pour ce problème, après application de cette propriété, il devient facile à résoudre: pour trouver le mode de l'arbre de tri binaire, il peut être simplifié pour parcourir le résultat de son ordre, tel que [1,2,3,3, 3,4,4, 7], c'est-à-dire que la position où chaque nombre apparaît est continue, et le nombre avec le plus d'occurrences consécutives est placé dans le résultat final. Évidemment, si l'espace supplémentaire n'est pas pris en compte, la méthode récursive ou non récursive de traversée dans l'ordre peut être utilisée pour enregistrer le résultat (valeur du nœud racine) de chaque sortie dans une structure de données telle qu'un tableau ou une file d'attente, et puis traversez à tour de rôle pour obtenir.

        Mais l'exigence avancée est qu'aucun espace supplémentaire n'est utilisé, mais la récursivité peut toujours être utilisée, donc elle peut être jugée dynamiquement au lieu de conserver tous les résultats de sortie:

        Définissez les variables Res, MaxNum, CurNum et CurVal utilisées pour enregistrer les résultats temporaires, c'est-à-dire comme suit. (L'idée du titre n'indique pas clairement la taille de la valeur du nœud, la valeur par défaut est int)

Nom de variable	Types de	Paraphrase
Res	vecteur <int>	Enregistrer tous les modes actuels
maxNum	int	Le nombre d'occurrences du mode correspondant à la Res actuelle
curne	int	Le nombre d'occurrences de la valeur de nœud précédente
CurVal	int	Valeur du nœud précédent

        Chaque fois que la valeur du nœud courant est obtenue de manière récursive, le jugement est effectué dans l'ordre:

        1. S'il est cohérent avec la valeur du nœud précédent (nœud parent), s'il est identique, le nombre d'occurrences de la valeur du nœud précédent CurNum augmente de 1; sinon, mettez à jour CurVal à la valeur du nœud actuel et définissez CurNum sur 1.

        2. Si le CurNum mis à jour est supérieur à MaxNum, s'il est supérieur, Res est effacé (il y a déjà un nombre avec plus d'occurrences que le "mode temporaire" actuel avec le plus d'occurrences, alors le nouveau nombre est le "mode temporaire" ), et placez le CurVal actuel dans Res, et définissez MaxNum sur CurNum; s'il est égal, cela signifie que la valeur du nœud est également le "mode temporaire", et mettez le CurVal actuel dans Res.

        Donc, jusqu'à la fin de la récursivité, la valeur contenue dans Res est le résultat 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;
    }
};