|
| 1 | +# 1110. Delete Nodes And Return Forest |
| 2 | + |
| 3 | +## Énoncé |
| 4 | + |
| 5 | +Étant donné la racine `root` d'un arbre binaire, chaque noeud de l'arbre a une valeur distincte. |
| 6 | + |
| 7 | +Après avoir supprimé tous les noeuds avec une valeur dans `to_delete`, il nous reste une forêt (une union disjointe d'arbres). |
| 8 | + |
| 9 | +Retournez les racines des arbres dans la forêt restante. Vous pouvez retourner le résultat dans n'importe quel ordre. |
| 10 | + |
| 11 | +## Exemple |
| 12 | + |
| 13 | +**Exemple 1:** |
| 14 | + |
| 15 | +<img src="./imgs/img1.png" width="237px" height="150px"/> |
| 16 | + |
| 17 | +**Input:** root = [1,2,3,4,5,6,7], to_delete = [3,5] |
| 18 | +**Output:** [[1,2,null,4],[6],[7]] |
| 19 | + |
| 20 | +**Exemple 2:** |
| 21 | +**Input:** root = [1,2,4,null,3], to_delete = [3] |
| 22 | +**Output:** [[1,2,4]] |
| 23 | + |
| 24 | +## Contraintes |
| 25 | + |
| 26 | +Le nombre de noeuds dans l'arbre donné est au maximum de `1000` |
| 27 | +Chaque noeud a une valeur distincte entre `1` et `1000` |
| 28 | +`to_delete.length <= 1000` |
| 29 | +`to_delete` contient des valeurs distinctes entre `1` et `1000` |
| 30 | + |
| 31 | +## Note personnelle |
| 32 | + |
| 33 | +Dans chaque approche proposée, une partie du code est commentée, celui-ci permet de libérer la mémoire des noeuds supprimés pour éviter les fuites de mémoires. |
| 34 | + |
| 35 | +### Approche 1: Trouver et Supprimer les Éléments dans les Forêts |
| 36 | + |
| 37 | +Cette approche consiste à stocker les racines des forêts dans un ensemble `unordered_set`. Pour chaque élément à supprimer, nous effectuons une recherche en profondeur (DFS) dans chaque forêt jusqu'à trouver l'élément à supprimer. À chaque suppression, nous créons les forêts résultantes que nous ajoutons à l'ensemble. |
| 38 | + |
| 39 | +```cpp |
| 40 | +// Fonction DFS pour trouver le noeud et son parent |
| 41 | +pair<TreeNode*, TreeNode*> dfs(TreeNode* root, int value){ |
| 42 | + // Si la racine est le noeud recherché |
| 43 | + if(root->val == value){ |
| 44 | + return {nullptr, root}; |
| 45 | + } |
| 46 | + |
| 47 | + stack<TreeNode*> sta; |
| 48 | + sta.push(root); |
| 49 | + |
| 50 | + while(!sta.empty()){ |
| 51 | + TreeNode* curr = sta.top(); |
| 52 | + sta.pop(); |
| 53 | + |
| 54 | + // Vérification du sous-arbre gauche |
| 55 | + if(curr->left){ |
| 56 | + if(curr->left->val == value){ |
| 57 | + return {curr, curr->left}; |
| 58 | + } |
| 59 | + sta.push(curr->left); |
| 60 | + } |
| 61 | + // Vérification du sous-arbre droit |
| 62 | + if(curr->right){ |
| 63 | + if(curr->right->val == value){ |
| 64 | + return {curr, curr->right}; |
| 65 | + } |
| 66 | + sta.push(curr->right); |
| 67 | + } |
| 68 | + } |
| 69 | + |
| 70 | + // Si le noeud avec la valeur donnée n'est pas trouvé |
| 71 | + return {nullptr, nullptr}; |
| 72 | +} |
| 73 | + |
| 74 | +vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) { |
| 75 | + unordered_set<TreeNode*> forests; |
| 76 | + forests.insert(root); // Initialiser la forêt avec la racine |
| 77 | + |
| 78 | + // Parcours de chaque élément a supprimé |
| 79 | + for(int element : to_delete){ |
| 80 | + // Parcours de chaque forêt |
| 81 | + for(TreeNode* f : forests){ |
| 82 | + pair<TreeNode*, TreeNode*> r = dfs(f, element); |
| 83 | + |
| 84 | + // Si le noeud à supprimer n'est pas trouvé |
| 85 | + if(!r.second){ |
| 86 | + continue; |
| 87 | + } |
| 88 | + |
| 89 | + // Si le noeud à supprimer est la racine |
| 90 | + if(!r.first){ |
| 91 | + forests.erase(r.second); |
| 92 | + } |
| 93 | + else{ |
| 94 | + // Détache le noeud à supprimer de son parent |
| 95 | + if(r.first->left == r.second){ |
| 96 | + r.first->left = nullptr; |
| 97 | + } |
| 98 | + else if(r.first->right == r.second){ |
| 99 | + r.first->right = nullptr; |
| 100 | + } |
| 101 | + } |
| 102 | + |
| 103 | + // Ajouter les sous-arbres du noeud supprimé à la forêt |
| 104 | + if(r.second->left){ |
| 105 | + forests.insert(r.second->left); |
| 106 | + } |
| 107 | + if(r.second->right){ |
| 108 | + forests.insert(r.second->right); |
| 109 | + } |
| 110 | + |
| 111 | + // Libérer la mémoire du noeud supprimé |
| 112 | + // delete r.second; |
| 113 | + |
| 114 | + break; |
| 115 | + } |
| 116 | + } |
| 117 | + |
| 118 | + // Retourner les racines des sous-arbres restants |
| 119 | + return vector<TreeNode*>(forests.begin(), forests.end()); |
| 120 | +} |
| 121 | +``` |
| 122 | +
|
| 123 | +- Complexité Temporelle: `O(n * m)` |
| 124 | +- Complexité Spatiale: `O(m + h)` |
| 125 | +- `n` est le nombre de noeuds dans l'arbre, `m` est le nombre d'éléments à supprimer, et `h` est la hauteur de l'arbre. |
| 126 | +
|
| 127 | +### Approche 2: Utiliser une HashMap pour Stocker les Éléments et Procéder à la Suppression |
| 128 | +
|
| 129 | +Cette approche consiste à stocker chaque noeud et son parent dans une HashMap avec la valeur du noeud comme clé, permettant une recherche efficace de l'élément à supprimer. La gestion des forêts reste la même que dans l'approche précédente. |
| 130 | +
|
| 131 | +```cpp |
| 132 | +// Fonction DFS pour remplir la map avec les noeuds et leurs parents |
| 133 | +void dfs(TreeNode* root, unordered_map<int, pair<TreeNode*, TreeNode*>> &mp){ |
| 134 | + if(root->left){ |
| 135 | + mp[root->left->val] = {root, root->left}; // Ajouter le noeud gauche et son parent |
| 136 | + dfs(root->left, mp); // Appel récursif sur le noeud gauche |
| 137 | + } |
| 138 | + if(root->right){ |
| 139 | + mp[root->right->val] = {root, root->right}; // Ajouter le noeud droit et son parent |
| 140 | + dfs(root->right, mp); // Appel récursif sur le noeud droit |
| 141 | + } |
| 142 | +} |
| 143 | +
|
| 144 | +vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) { |
| 145 | + unordered_map<int, pair<TreeNode*, TreeNode*>> mp; // Map pour stocker les noeuds et leurs parents |
| 146 | + unordered_set<TreeNode*> set; // Ensemble pour stocker les racines des sous-arbres |
| 147 | +
|
| 148 | + mp[root->val] = {nullptr, root}; // La racine n'a pas de parent |
| 149 | + set.insert(root); // Ajouter la racine à l'ensemble |
| 150 | +
|
| 151 | + dfs(root, mp); // Remplir la map avec les noeuds de l'arbre |
| 152 | +
|
| 153 | + // Traiter chaque élément à supprimer |
| 154 | + for(int element: to_delete){ |
| 155 | + pair<TreeNode*, TreeNode*> curr = mp[element]; |
| 156 | +
|
| 157 | + // Détache le noeud à supprimer de son parent |
| 158 | + if(curr.first){ |
| 159 | + if(curr.first->left == curr.second){ |
| 160 | + curr.first->left = nullptr; |
| 161 | + } |
| 162 | + else if(curr.first->right == curr.second){ |
| 163 | + curr.first->right = nullptr; |
| 164 | + } |
| 165 | + } |
| 166 | +
|
| 167 | + set.erase(curr.second); // Retire le noeud à supprimer de l'ensemble |
| 168 | +
|
| 169 | + // Ajouter les sous-arbres du noeud supprimé à l'ensemble |
| 170 | + if(curr.second->left){ |
| 171 | + set.insert(curr.second->left); |
| 172 | + } |
| 173 | + if(curr.second->right){ |
| 174 | + set.insert(curr.second->right); |
| 175 | + } |
| 176 | + } |
| 177 | +
|
| 178 | + // Libérer la mémoire des noeuds supprimés |
| 179 | + // for(int element: to_delete){ |
| 180 | + // delete mp[element].second; |
| 181 | + // } |
| 182 | +
|
| 183 | + // Retourner les racines des sous-arbres restants |
| 184 | + return vector<TreeNode*>(set.begin(), set.end()); |
| 185 | +} |
| 186 | +``` |
| 187 | + |
| 188 | +- Complexité Temporelle: `O(n + m)` |
| 189 | +- Complexité Spatiale: `O(n + m + h)` |
| 190 | +- `n` est le nombre de noeuds dans l'arbre, `m` est le nombre d'éléments à supprimer, et `h` est la hauteur de l'arbre. |
| 191 | + |
| 192 | +### Approche 3: Parcourir l'Arbre et Supprimer les Éléments Simultanément |
| 193 | + |
| 194 | +Cette approche parcourt l'arbre en profondeur tout en supprimant les éléments. |
| 195 | + |
| 196 | +Chaque itération retourne `true` ou `false`pour indiquer si le noeud enfant concerné doit être supprimé ou non. La liste `to_delete` est convertie en un ensemble `unrodered_set` pour faciliter la vérification. |
| 197 | + |
| 198 | +```cpp |
| 199 | +// Fonction pour supprimer un noeud et ajuster l'arbre en conséquence |
| 200 | +void deleteNode(TreeNode* parent, TreeNode* child, bool isLeft, vector<TreeNode*> &ans, unordered_set<int> &toDelete){ |
| 201 | + toDelete.erase(child->val); // Supprimer le noeud du set toDelete |
| 202 | + |
| 203 | + // Ajouter les enfants du noeud supprimé à la liste des résultats |
| 204 | + if(child->left){ |
| 205 | + ans.push_back(child->left); |
| 206 | + } |
| 207 | + if(child->right){ |
| 208 | + ans.push_back(child->right); |
| 209 | + } |
| 210 | + |
| 211 | + // Détacher le noeud supprimé de son parent |
| 212 | + if(isLeft){ |
| 213 | + parent->left = nullptr; |
| 214 | + } |
| 215 | + else{ |
| 216 | + parent->right = nullptr; |
| 217 | + } |
| 218 | + |
| 219 | + // Libérer la mémoire des noeuds supprimés |
| 220 | + // delete child; |
| 221 | +} |
| 222 | + |
| 223 | +// Fonction DFS pour explorer et marquer les noeuds à supprimer |
| 224 | +bool dfs(TreeNode* root, vector<TreeNode*> &ans, unordered_set<int> &toDelete){ |
| 225 | + if(root->left && dfs(root->left, ans, toDelete)){ |
| 226 | + deleteNode(root, root->left, true, ans, toDelete); |
| 227 | + } |
| 228 | + if(root->right && dfs(root->right, ans, toDelete)){ |
| 229 | + deleteNode(root, root->right, false, ans, toDelete); |
| 230 | + } |
| 231 | + |
| 232 | + // Retourne true si le noeud actuel doit être supprimé |
| 233 | + return toDelete.find(root->val) != toDelete.end(); |
| 234 | +} |
| 235 | + |
| 236 | +vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) { |
| 237 | + vector<TreeNode*> ans; |
| 238 | + unordered_set<int> toDelete(to_delete.begin(), to_delete.end()); |
| 239 | + |
| 240 | + // Si la racine doit être supprimée, ajouter ses enfants à la liste des résultats |
| 241 | + if(dfs(root, ans, toDelete)){ |
| 242 | + if(root->left){ |
| 243 | + ans.push_back(root->left); |
| 244 | + } |
| 245 | + if(root->right){ |
| 246 | + ans.push_back(root->right); |
| 247 | + } |
| 248 | + |
| 249 | + // Libérer la mémoire des noeuds supprimés |
| 250 | + // delete root; |
| 251 | + } |
| 252 | + // Sinon, ajouter la racine à la liste des résultats |
| 253 | + else{ |
| 254 | + ans.push_back(root); |
| 255 | + } |
| 256 | + |
| 257 | + // Retourner les racines des sous-arbres restants |
| 258 | + return ans; |
| 259 | +} |
| 260 | +``` |
| 261 | +
|
| 262 | +- Complexité Temporelle: `O(n + m)` |
| 263 | +- Complexité Spatiale: `O(m + h)` |
| 264 | +- `n` est le nombre de noeuds dans l'arbre, `m` est le nombre d'éléments à supprimer, et `h` est la hauteur de l'arbre. |
| 265 | +
|
| 266 | +<img src="./imgs/runtime.png"/> |
| 267 | +<img src="./imgs/memory.png"/> |
0 commit comments