$course$/QCM de NSI/Terminale/Arbres binaires de recherche Propriété d'ordre dans un arbre binaire de
recherche, opérations de recherche, d'insertion et
de suppression, complexité dans le meilleur et
dans le pire cas, équilibrage, applications aux
ensembles ordonnés dynamiques et aux dictionnaires
triés.

]]> Arbres binaires de recherche — Q01 : Propriété fondamentale Quelle est la propriété fondamentale d'un
arbre binaire de recherche ?

]]> Les arbres binaires de recherche permettent de
maintenir un ensemble ordonné dynamique, en
offrant des opérations de recherche,
d'insertion et de suppression efficaces lorsque
l'arbre reste équilibré.

]]> 1.0 0.0 0 true true abc Toutes les feuilles se trouvent exactement au même niveau

]]> Cette description correspond à un arbre
parfait, et non à un arbre binaire de
recherche. Un arbre binaire de recherche
se définit par une propriété d'ordre, pas
par la position de ses feuilles.

]]> Chaque nœud possède exactement deux enfants

]]> Cette description correspond à un arbre
plein, qui n'a aucun rapport direct avec
l'ordre des valeurs.

]]> Sous-arbre gauche inférieur, sous-arbre droit supérieur

]]> C'est la propriété d'ordre qui rend la
recherche efficace en $O(\log n)$ dans un
arbre équilibré. Cette propriété doit être
vérifiée pour chaque nœud de l'arbre, et
non uniquement pour la racine.

]]> La racine contient toujours la plus grande valeur de l'arbre

]]> Dans un arbre binaire de recherche, la racine n'a aucune raison de porter la plus grande valeur : les valeurs plus grandes qu'elle se trouvent dans son sous-arbre droit, et la racine peut être n'importe quelle valeur.

]]> Arbres binaires de recherche — Q02 : Complexité de la recherche Dans un arbre binaire de recherche équilibré
contenant $n$ éléments, quelle est la complexité
de la recherche d'une valeur ?

]]> Cette efficacité explique pourquoi les arbres
binaires de recherche sont utilisés pour
implémenter des ensembles et dictionnaires
triés. Cette complexité dépend néanmoins
crucialement du fait que l'arbre reste
équilibré.

]]> 1.0 0.0 0 true true abc $O(n^2)$

]]> Aucune raison d'avoir une complexité
quadratique pour une simple recherche dans
un arbre.

]]> $O(1)$

]]> On ne peut pas accéder à un élément
quelconque en temps constant dans un arbre
binaire de recherche. La complexité dépend
au moins de la hauteur de l'arbre.

]]> $O(n)$

]]> Cette complexité correspond au pire cas
d'un arbre dégénéré en peigne. Pour un
arbre équilibré, on fait nettement mieux.

]]> $O(\log n)$

]]> À chaque comparaison, on élimine la moitié
des nœuds (on descend dans le sous-arbre
gauche ou dans le sous-arbre droit). Le
nombre d'étapes est donc proportionnel à
la hauteur de l'arbre, qui vaut
$O(\log n)$ lorsque l'arbre est équilibré.

]]> Arbres binaires de recherche — Q03 : Cas pire Quelle est la complexité de la recherche dans
un arbre binaire de recherche dans le pire cas, sans contrainte d'équilibrage ?

]]> Ce phénomène de dégénérescence explique pourquoi on cherche à garder l'arbre équilibré : la recherche dans un arbre binaire de recherche équilibré est de coût logarithmique, en $O(\log n)$.

]]> 1.0 0.0 0 true true abc $O(\sqrt{n})$

]]> Aucune raison particulière n'amène à une
complexité de cette forme dans un arbre
binaire de recherche.

]]> $O(\log n)$ dans tous les cas

]]> Sans équilibrage, l'arbre peut dégénérer.
La complexité $O(\log n)$ n'est garantie
que si l'arbre reste équilibré.

]]> $O(n^2)$, soit quadratique

]]> Même dans le pire cas, la recherche reste
en $O(n)$. La hauteur de l'arbre, qui peut
atteindre $n$, est en cause, mais la
complexité ne devient pas quadratique.

]]> $O(n)$, arbre dégénéré en peigne

]]> Si l'on insère par exemple les valeurs
$1, 2, 3, \ldots, n$ dans l'ordre, l'arbre
devient une liste chaînée par la droite.
La recherche y est alors en $O(n)$, comme
dans un parcours linéaire.

]]> Arbres binaires de recherche — Q04 : Parcours infixe Que donne un parcours infixe sur un arbre
binaire de recherche ?

]]> Cette propriété permet de transformer un
arbre binaire de recherche en un tableau
trié en $O(n)$. C'est aussi pour cette raison
que cette structure est naturelle pour
maintenir un ensemble ordonné.

]]> 1.0 0.0 0 true true abc Les valeurs dans un ordre aléatoire

]]> Un parcours d'arbre est strictement
déterministe : il ne fait jamais appel au
hasard.

]]> Les valeurs dans l'ordre croissant

]]> C'est précisément la propriété remarquable
des arbres binaires de recherche. Le
parcours infixe (sous-arbre gauche, racine,
sous-arbre droit) visite naturellement les
valeurs dans l'ordre croissant.

]]> Les valeurs dans l'ordre décroissant

]]> Pour obtenir l'ordre décroissant, il
faudrait inverser le parcours infixe en
visitant d'abord le sous-arbre droit, puis
la racine, puis le sous-arbre gauche.

]]> Aucune valeur particulière n'est visitée

]]> Un parcours visite chaque nœud exactement
une fois. Toutes les valeurs sont donc
parcourues.

]]> Arbres binaires de recherche — Q05 : Insertion Pour insérer une valeur $v$ dans un arbre
binaire de recherche, on procède de la manière
suivante :

]]> L'insertion s'effectue en $O(h)$, où $h$ est
la hauteur de l'arbre. Lorsque l'arbre est
équilibré, on a $h = O(\log n)$. Sinon, dans
le pire cas, l'insertion peut atteindre
$O(n)$.

]]> 1.0 0.0 0 true true abc On descend en comparant, puis on insère comme nouvelle feuille

]]> Si la valeur $v$ est plus petite que celle
du nœud courant, on descend dans le
sous-arbre gauche ; sinon dans le
sous-arbre droit. On répète jusqu'à
rencontrer une place vide, où l'on crée
une nouvelle feuille.

]]> On trie les valeurs, puis on la place

]]> L'insertion est une opération locale qui
préserve l'invariant d'ordre. Aucun tri
global n'est nécessaire.

]]> On la place toujours à la racine

]]> Insérer la nouvelle valeur à la racine
briserait la propriété d'ordre. L'insertion
doit au contraire respecter la structure
existante.

]]> On la place dans la première feuille rencontrée, sans comparaison

]]> Sans comparaison avec la valeur des nœuds,
la propriété d'ordre serait violée et
l'arbre cesserait d'être un arbre binaire
de recherche.

]]> Arbres binaires de recherche — Q06 : Nœuds visités lors d'une recherche Dans un arbre binaire de recherche, la racine porte $50$ ; ses enfants sont $30$ à gauche et $70$ à droite ; $30$ a pour enfants $20$ et $40$, et $70$ a pour enfants $60$ et $80$. On recherche la clé $60$. Quels nœuds sont visités, dans l'ordre ?

]]> La recherche d'une clé part de la racine et, à chaque nœud, compare la clé cherchée à celle du nœud : plus petite, on descend à gauche ; plus grande, à droite. On visite ainsi au plus un nœud par niveau de l'arbre.

]]> 1.0 0.0 0 true true abc $50$, $30$, $70$, $60$

]]> Erreur : tu visites l'arbre niveau par niveau. La recherche compare $60$ à $50$ et part aussitôt à droite : le sous-arbre gauche, qui ne contient que des clés plus petites que $50$, n'est jamais visité.

]]> $50$, $70$, $60$

]]> Bonne réponse : $60 > 50$, on descend à droite vers $70$ ; $60 < 70$, on descend à gauche et l'on trouve $60$. Trois nœuds suffisent.

]]> $20$, $30$, $40$, $50$, $60$

]]> Erreur : tu suis le parcours infixe jusqu'à trouver la clé. La recherche part de la racine et, grâce à la propriété d'ordre, ne descend que d'un côté à chaque étape.

]]> $50$, $30$, $20$, $40$, $70$, $60$

]]> Erreur : tu suis le parcours préfixe jusqu'à trouver la clé. Comparer $60$ à la racine suffit pour savoir qu'il est inutile d'explorer le sous-arbre gauche.

]]> Arbres binaires de recherche — Q07 : Comparaison avec un tableau trié Quel est l'avantage d'un arbre binaire de
recherche équilibré par rapport à un tableau
trié ?

]]> Le compromis est clair. Si l'on a beaucoup de
recherches mais peu d'insertions, le tableau
trié peut suffire. Pour un mélange dynamique
d'opérations, l'arbre binaire de recherche
équilibré est mieux adapté.

]]> 1.0 0.0 0 true true abc La recherche y est plus rapide

]]> La recherche dichotomique dans un tableau
trié est elle aussi en $O(\log n)$. Les
deux structures sont équivalentes pour la
recherche.

]]> Aucune différence n'existe entre les deux structures

]]> Les deux structures se distinguent
précisément par leur comportement face
aux opérations dynamiques d'ajout et de
suppression.

]]> Insertion et suppression en $O(\log n)$ au lieu de $O(n)$

]]> C'est le principal atout d'un arbre
binaire de recherche équilibré. On peut y
maintenir un ensemble trié dynamique avec
toutes les opérations en $O(\log n)$,
alors qu'une insertion ou une suppression
au milieu d'un tableau trié coûte $O(n)$.

]]> Il consomme moins de mémoire qu'un tableau

]]> Au contraire, un arbre binaire de
recherche consomme en général plus de
mémoire qu'un tableau, en raison des
références entre nœuds.

]]> Arbres binaires de recherche — Q08 : Construire l'arbre On insère successivement les valeurs $5$, $3$, $7$, $1$, $4$ dans un arbre binaire de
recherche initialement vide. Que devient la
racine ?

]]> L'ordre d'insertion détermine la forme de
l'arbre. Insérer dans l'ordre $1, 3, 4, 5, 7$
donnerait un peigne à droite (cas dégénéré).
C'est précisément pour cette raison que les
structures auto-équilibrantes sont
importantes en pratique.

]]> 1.0 0.0 0 true true abc $5$

]]> La première valeur insérée devient la
racine. Toutes les insertions suivantes
deviennent des descendants de cette
racine.

]]> $7$

]]> La valeur $7$ est plus grande que $5$,
donc elle est insérée à droite de la
racine, mais elle ne devient pas la
racine elle-même.

]]> $1$

]]> La valeur $1$ est la plus petite de toutes et
finit en feuille tout à gauche. La racine est toujours
la première valeur insérée.

]]> $4$

]]> La valeur $4$ est insérée en dernier. Elle
finit comme enfant droit de $3$, et n'occupe
pas la racine.

]]> Arbres binaires de recherche — Q09 : Cas d'usage Lequel des cas suivants est un usage typique
d'un arbre binaire de recherche ?

]]> En pratique, un arbre binaire de recherche maintenu équilibré permet d'ajouter et de chercher rapidement des éléments tout en les gardant ordonnés : le parcours infixe les restitue triés à tout moment.

]]> 1.0 0.0 0 true true abc Maintenir un ensemble trié dynamique avec ajouts fréquents

]]> C'est l'usage emblématique. On peut par
exemple gérer une liste de scores triés
en temps réel, ou un dictionnaire dont
les clés doivent rester ordonnées.

]]> Compter le nombre de mots dans un texte

]]> Un compteur simple suffit pour cette
tâche. L'utilisation d'un arbre binaire
de recherche serait disproportionnée.

]]> Afficher une image

]]> L'affichage d'une image n'a aucun rapport
avec la structure d'arbre binaire de
recherche.

]]> Calculer la somme de tous les éléments d'une liste donnée

]]> Un parcours linéaire de la liste suffit.
Aucune structure ordonnée n'est
nécessaire.

]]> Arbres binaires de recherche — Q10 : Recherche récursive Quelle fonction Python recherche correctement
la valeur v dans un arbre binaire de
recherche ?

]]> C'est précisément la propriété d'ordre qui
permet d'éliminer la moitié de l'arbre à
chaque comparaison. Sans cette propriété, on
retomberait sur un parcours linéaire de tous
les nœuds.

]]> 1.0 0.0 0 true true abc def chercher(n, v): if n is None: return False if v == n.valeur: return True if v < n.valeur: return chercher(n.gauche, v) return chercher(n.droit, v)]]> Cette fonction ne descend que dans un seul sous-arbre selon la comparaison.
C'est ce qui donne la complexité
$O(\log n)$ pour un arbre équilibré.

]]> def chercher(n, v): if v == n.valeur: return True if v < n.valeur: return chercher(n.gauche, v) return chercher(n.droit, v)]]> Erreur classique : le cas de base de l'arbre
vide manque. Dès que v est absente, la
descente atteint un sous-arbre None et
n.valeur lève une AttributeError au lieu
de renvoyer False.

]]> def chercher(n, v): if n is None: return False if v == n.valeur: return True if v < n.valeur: return chercher(n.droit, v) return chercher(n.gauche, v)]]> Erreur : les directions sont inversées. Dans
un arbre binaire de recherche, les valeurs
plus petites que n.valeur sont à gauche.
Cette fonction ne trouve que la valeur de la
racine.

]]> def chercher(n, v): if n is None: return False if n.valeur == v: return True return chercher(n.gauche, v) or chercher(n.droit, v)]]> Cette fonction parcourt l'arbre entier
sans exploiter la propriété d'ordre. Sa
complexité est en $O(n)$ et non en
$O(\log n)$.

]]> Arbres binaires de recherche — Q13 : Insertion dans le pire cas Dans un arbre binaire de recherche non équilibré, quelle séquence d'insertions
conduit au pire cas (forme dégénérée) ?

]]> Pour éviter ce piège, on peut mélanger les valeurs avant de les insérer, ou choisir un ordre d'insertion qui place en premier la médiane, puis les médianes de chaque moitié.

]]> 1.0 0.0 0 true true abc Insérer les valeurs en commençant par la médiane

]]> Au contraire, insérer la médiane en
premier conduit à un arbre bien
équilibré.

]]> Insérer une seule valeur

]]> Un arbre composé d'un seul nœud ne pose
évidemment aucun problème de
dégénérescence.

]]> Insérer les valeurs dans un ordre aléatoire

]]> Avec un ordre aléatoire, on tend vers une
bonne forme d'arbre, dont la hauteur est
en $O(\log n)$ en espérance.

]]> Insérer les valeurs déjà triées

]]> En insérant les valeurs $1, 2, 3, \ldots, n$
dans l'ordre, chaque nouvelle valeur va à
droite de la précédente, ce qui crée un
peigne. La hauteur atteint alors $n - 1$
et toutes les opérations dégénèrent en
$O(n)$.

]]> Arbres binaires de recherche — Q14 : Application du parcours infixe Comment obtenir efficacement les valeurs
triées d'un arbre binaire de recherche ?

]]> Cette propriété permet d'utiliser un arbre
binaire de recherche pour réaliser un tri.
Si l'arbre reste équilibré, les $n$ insertions
coûtent $O(n \log n)$ au total ; avec le
parcours infixe en $O(n)$, on obtient un tri
en $O(n \log n)$, comparable au tri fusion.

]]> 1.0 0.0 0 true true abc Trier les valeurs à chaque opération

]]> Un arbre binaire de recherche maintient
déjà l'ordre par sa structure même. Il
serait redondant de retrier les valeurs.

]]> Ne renvoyer que les feuilles de l'arbre

]]> On perdrait alors toutes les valeurs des
nœuds internes, ce qui est manifestement
incorrect.

]]> Effectuer plutôt un simple parcours préfixe

]]> Le parcours préfixe ne donne pas les
valeurs triées en général. Seul le
parcours infixe possède cette propriété.

]]> Effectuer un parcours infixe (ordre croissant)

]]> Le parcours infixe en $O(n)$ donne
directement les valeurs triées. On ne
peut pas faire mieux : il faut bien
visiter chaque élément au moins une
fois.

]]> Arbres binaires de recherche — Q15 : Code d'insertion récursive Quelle fonction Python insère correctement la
valeur v dans un arbre binaire de
recherche, en renvoyant la nouvelle racine ?

]]> Cette fonction est typique : elle parcourt
l'arbre depuis la racine en comparant les
valeurs, et crée un nouveau nœud à la place
vide trouvée. Sa complexité est en $O(h)$,
où $h$ est la hauteur de l'arbre.

]]> 1.0 0.0 0 true true abc def inserer(n, v): if n is None: return Noeud(v) if v < n.valeur: n.gauche = inserer(n.gauche, v) else: n.droit = inserer(n.droit, v) return n]]> Si l'arbre est vide, la fonction crée un
nouveau nœud. Sinon, elle descend
récursivement à gauche ou à droite selon
la comparaison, puis réaffecte le
sous-arbre modifié.

]]> def inserer(n, v): if n is None: n = Noeud(v) elif v < n.valeur: inserer(n.gauche, v) else: inserer(n.droit, v) return n]]> Erreur classique : les appels récursifs ne
réaffectent pas leur résultat. Le nœud créé
au cas de base est perdu (l'affectation
locale n = Noeud(v) ne modifie pas l'arbre
du parent). Il faut écrire
n.gauche = inserer(n.gauche, v).

]]> def inserer(n, v): if n is None: return Noeud(v) if v < n.valeur: n.gauche = inserer(n.gauche, v) else: n.droit = inserer(n.droit, v)]]> Erreur classique : le return n final manque.
Pour tout arbre non vide, la fonction renvoie
None, que le parent affecte à n.gauche ou
n.droit : le sous-arbre existant est détruit
à chaque insertion.

]]> def inserer(n, v): if v < n.valeur: n.gauche = Noeud(v) else: n.droit = Noeud(v) return n]]> Erreur : la fonction ne descend pas dans
l'arbre. Elle accroche le nouveau nœud
directement sous la racine, en écrasant le
sous-arbre qui s'y trouvait déjà, et elle
échoue sur un arbre vide.

]]> Arbres binaires de recherche — Q16 : Construire un arbre équilibré Pour construire un arbre binaire de recherche
équilibré à partir d'un tableau trié, quelle
stratégie est la plus simple ?

]]> Cet algorithme est en $O(n)$. Il est utile
pour reconstruire un arbre équilibré à
partir d'une séquence triée, par exemple
lors d'une migration de données.

]]> 1.0 0.0 0 true true abc Insérer les éléments dans un ordre aléatoire

]]> Cette approche donne un arbre presque
équilibré en moyenne, mais sans aucune
garantie absolue.

]]> Insérer les éléments directement dans l'ordre exact du tableau

]]> Cette stratégie produit précisément un
peigne dégénéré, puisque les valeurs
sont déjà triées.

]]> Le milieu comme racine, puis récursivement des deux côtés

]]> C'est l'algorithme classique. La moitié
de gauche devient le sous-arbre gauche,
construit récursivement par la même
méthode, et de même pour la moitié de
droite. L'arbre obtenu est parfaitement
équilibré, de hauteur $O(\log n)$.

]]> Insérer les éléments du dernier au premier

]]> Cette stratégie produit un peigne
dégénéré dans l'autre sens, ce qui n'est
pas plus satisfaisant.

]]> Arbres binaires de recherche — Q17 : Échec de la recherche Lorsque la recherche d'une valeur absente
se termine dans un arbre binaire de recherche,
à quel endroit s'arrête-t-on ?

]]> C'est ce comportement qui permet la recherche
en $O(h)$ : on ne descend que dans une seule
branche, ce qui prend au plus $\log n$
étapes pour un arbre équilibré.

]]> 1.0 0.0 0 true true abc À la racine de l'arbre

]]> On s'arrête en général à un endroit plus
profond dans l'arbre, lorsque la branche
recherchée est vide.

]]> La fonction lève une exception

]]> On renvoie typiquement la valeur False
ou None, sans lever d'exception
(sauf si on adopte volontairement cette
convention).

]]> À un sous-arbre vide (None)

]]> À chaque étape, on choisit le sous-arbre
gauche ou le sous-arbre droit. Si la
valeur n'est jamais égale au nœud
courant et que l'on atteint un
sous-arbre vide, c'est qu'elle est
absente.

]]> À une feuille quelconque, peu importe sa valeur

]]> On ne s'arrête pas systématiquement à
une feuille. On peut s'arrêter à un
sous-arbre vide pendant à un nœud
interne.

]]> Arbres binaires de recherche — Q18 : Vérifier la propriété d'ordre Pour vérifier qu'un arbre binaire respecte la
propriété d'arbre binaire de recherche, il
ne suffit pas de vérifier localement à
chaque nœud que :

]]> L'algorithme correct consiste à transmettre
récursivement les bornes (min, max) que
la valeur de chaque nœud doit respecter. La
racine accepte toutes les valeurs, le
sous-arbre gauche reçoit l'intervalle
$(\min, \text{valeur})$ et le sous-arbre
droit reçoit l'intervalle
$(\text{valeur}, \max)$.

]]> 1.0 0.0 0 true true abc Les feuilles se trouvent toutes au même niveau

]]> Aucune contrainte de niveau n'est
imposée dans un arbre binaire de
recherche.

]]> La hauteur des sous-arbres est équilibrée

]]> Cette propriété correspond à
l'équilibre, et non à la propriété
d'ordre qui définit un arbre binaire de
recherche.

]]> L'enfant gauche est plus petit, le droit plus grand

]]> C'est un piège classique. Vérifier
uniquement les enfants directs ne
suffit pas. La propriété d'arbre
binaire de recherche demande que
tout le sous-arbre gauche soit
inférieur à la valeur du nœud, et pas
seulement la racine de ce sous-arbre.

]]> La valeur du nœud est exactement la moyenne de celles de ses enfants

]]> Cette propriété correspond à un autre
type d'arbre, mais elle n'a aucun
rapport avec la définition d'un arbre
binaire de recherche.

]]> Arbres binaires de recherche — Q20 : Lecture d'un arbre On insère successivement les valeurs $5$, $2$, $8$, $1$, $3$ dans un arbre binaire de
recherche initialement vide. Quel est le
résultat de son parcours infixe ?

]]> Cet exemple illustre parfaitement la
propriété d'ordre. Dessiner l'arbre est
souvent utile pour visualiser et vérifier
les différents parcours.

]]> 1.0 0.0 0 true true abc $8, 5, 3, 2, 1$ (ordre décroissant)

]]> Cette séquence correspond au parcours
infixe inversé, et non au parcours
infixe standard.

]]> $1, 2, 3, 5, 8$ (ordre croissant)

]]> Le parcours infixe donne toujours les
valeurs en ordre croissant. On peut le
vérifier en construisant l'arbre :
racine $5$, sous-arbre gauche enraciné en $2$ (avec $1$ et $3$), sous-arbre droit réduit à $8$. Le parcours infixe
donne bien $1, 2, 3, 5, 8$.

]]> $5, 2, 1, 3, 8$ (parcours préfixe)

]]> Cette séquence correspond au parcours
préfixe (racine, gauche, droite),
et non au parcours infixe.

]]> $5, 2, 8, 1, 3$ (ordre d'insertion)

]]> Le parcours infixe d'un arbre binaire
de recherche donne les valeurs triées,
et non l'ordre d'insertion d'origine.

]]> Arbres binaires de recherche — Q21 : Du parcours préfixe au parcours suffixe Le parcours préfixe d'un arbre binaire de recherche donne les clés $8$, $3$, $1$, $6$, $10$, $14$. Quel est le parcours suffixe de cet arbre ?

]]> Le parcours préfixe commence par la racine, ici $8$. En insérant les clés dans l'ordre du parcours préfixe, on reconstruit le même arbre : $3$ à gauche de $8$, $1$ et $6$ sous $3$, $10$ à droite de $8$, puis $14$ à droite de $10$. Il ne reste qu'à le parcourir en ordre suffixe.

]]> 1.0 0.0 0 true true abc $1$, $3$, $6$, $8$, $10$, $14$

]]> Erreur : c'est le parcours infixe, qui donne toujours les clés triées dans un arbre binaire de recherche. Le parcours suffixe traite chaque nœud après ses deux sous-arbres.

]]> $14$, $10$, $6$, $1$, $3$, $8$

]]> Erreur : le parcours suffixe n'est pas le préfixe lu à l'envers. Il visite d'abord le sous-arbre gauche, puis le droit, puis le nœud.

]]> $1$, $6$, $3$, $10$, $14$, $8$

]]> Erreur : $14$ est l'enfant droit de $10$. En suffixe, un nœud vient après ses enfants : $14$ doit donc précéder $10$.

]]> $1$, $6$, $3$, $14$, $10$, $8$

]]> Bonne réponse : la racine est $8$ ; à gauche, $3$ a pour enfants $1$ et $6$ ; à droite, $10$ a pour enfant droit $14$. Le suffixe donne $1$, $6$, $3$, puis $14$, $10$, et enfin $8$.

]]> Arbres binaires de recherche — Q23 : Tri par arbre binaire de recherche Le tri par arbre binaire de recherche, qui
consiste à insérer $n$ valeurs dans un arbre
puis à effectuer un parcours infixe, a une
complexité de :

]]> Cet algorithme illustre un compromis : il est avantageux pour des données aléatoires, mais fragile dans le pire cas. C'est pourquoi on préfère souvent le tri fusion, dont le coût reste en $O(n \log n)$ dans tous les cas.

]]> 1.0 0.0 0 true true abc $O(n!)$, à cause des $n!$ ordres d'insertion possibles

]]> Le nombre d'ordres d'insertion possibles
n'intervient pas : on n'en suit qu'un
seul, celui des données. Une complexité
factorielle ne correspond à aucun
algorithme de tri raisonnable.

]]> $O(n \log n)$ en moyenne, $O(n^2)$ au pire

]]> Chaque insertion est en $O(\log n)$ en
moyenne, ce qui donne $O(n \log n)$
pour les $n$ insertions, auxquelles
s'ajoute $O(n)$ pour le parcours
infixe. Total : $O(n \log n)$ en
moyenne. Mais avec un ordre
d'insertion défavorable, la hauteur
explose et la complexité atteint
$O(n^2)$.

]]> $O(n)$ quel que soit l'ordre d'insertion

]]> Chaque insertion descend dans l'arbre en faisant une comparaison par niveau. Même dans un arbre équilibré, de hauteur proche de $\log_2 n$, les $n$ insertions demandent de l'ordre de $n \log_2 n$ comparaisons, et bien davantage si l'arbre dégénère.

]]> $O(2^n)$, car chaque nœud possède deux sous-arbres

]]> Chaque insertion ne suit qu'un seul
chemin de la racine vers une feuille ;
les deux sous-arbres d'un nœud ne sont
jamais explorés tous les deux. Une
complexité exponentielle n'a aucune
raison d'apparaître dans un tri.

]]> Arbres binaires de recherche — Q25 : Quand utiliser un arbre binaire de recherche ? Lequel des cas suivants justifie l'usage d'un arbre binaire de recherche plutôt qu'une autre structure ?

]]> Pour résumer : on utilise un arbre binaire
de recherche pour des accès dynamiques
avec maintien d'un ordre sur les
valeurs. Pour des données statiques ou
sans besoin d'ordre, des structures plus
simples suffisent.

]]> 1.0 0.0 0 true true abc Un dictionnaire à clés triées dynamiquement

]]> C'est exactement le cas d'usage d'un arbre binaire de recherche : maintenu équilibré, il permet d'ajouter ou de chercher une clé en $O(\log n)$ tout en gardant les clés ordonnées, que le parcours infixe restitue triées.

]]> Calculer la somme de tous les éléments d'une grande liste

]]> Un parcours linéaire en $O(n)$ suffit
pour cette tâche. Aucune structure
d'arbre n'apporterait de gain.

]]> Stocker une liste fixe de noms à afficher

]]> Pour des données statiques, une liste
triée stockée dans un tableau suffit.
Aucun arbre binaire de recherche
n'est nécessaire.

]]> Trier $1\,000$ entiers une seule fois

]]> Pour ce besoin, un algorithme de tri classique, comme le tri fusion, est plus simple et tout aussi efficace.

]]> Arbres binaires de recherche — Q26 : Trace d'insertions successives On part d'un arbre binaire de recherche
vide. On y insère successivement les valeurs
$10, 5, 15, 3, 7, 12$. À quoi ressemble la
structure obtenue ?

]]> Cet arbre obtenu ($6$ nœuds, hauteur $2$) est
bien équilibré, ce qui n'est pas un hasard :
la séquence d'insertion alterne intelligemment
entre les côtés. Avec une mauvaise séquence
($1, 2, 3, 4, 5, 6$), on aurait obtenu un
peigne de hauteur $5$.

]]> 1.0 0.0 0 true true abc Tous les nœuds sont des feuilles d'une
racine vide

]]> Erreur : un arbre binaire de recherche
n'a pas de « racine vide ». La première
valeur insérée devient la racine, et les
suivantes sont placées comme descendants.

]]> Tous les nœuds sur une branche droite,
formant un peigne

]]> Erreur : on aurait un peigne uniquement
si les valeurs étaient insérées dans
l'ordre croissant ou décroissant. Ici,
l'ordre est plus équilibré.

]]> Racine $5$ ; tous les autres nœuds
répartis selon leur valeur

]]> Erreur : la racine est toujours la
première valeur insérée, ici $10$,
pas $5$.

]]> Racine $10$, à gauche $5$ (avec $3$ et $7$), à droite $15$ (avec $12$)

]]> Bonne réponse : à chaque insertion, on
compare avec la racine pour choisir le
sous-arbre. $10$ devient racine. $5 < 10$
va à gauche. $15 > 10$ va à droite. $3 < 10$
puis $3 < 5$ va à gauche de $5$. $7 < 10$
puis $7 > 5$ va à droite de $5$. $12 > 10$
puis $12 < 15$ va à gauche de $15$.

]]> Arbres binaires de recherche — Q27 : Code de vérification de la propriété Quelle fonction Python vérifie correctement
qu'un arbre binaire respecte la propriété
d'arbre binaire de recherche (en utilisant
des bornes minimum et maximum) ?

]]> Le piège pédagogique de cette question est
la version qui ne compare chaque nœud qu'à ses
enfants directs : elle semble naturelle mais
rate les violations à distance. C'est
pour cela que la transmission de bornes par
paramètre est essentielle : elle propage la
contrainte d'ordre tout au long de la
descente récursive.

]]> 1.0 0.0 0 true true abc def est_abr(n): if n is None: return True if n.gauche and n.gauche.valeur >= n.valeur: return False if n.droit and n.droit.valeur <= n.valeur: return False return est_abr(n.gauche) and est_abr(n.droit)]]> Erreur classique : on ne vérifie que la
relation parent/enfant direct. Cela rate
des cas comme racine $10$, gauche $5$,
droite-gauche-droite $20$ (qui est dans
le sous-arbre gauche de $10$ mais
supérieure à $10$). L'arbre serait
déclaré valide à tort.

]]> def est_abr(n, mini=float('-inf'), maxi=float('inf')): if n is None: return True if not (mini < n.valeur < maxi): return False return est_abr(n.gauche, mini, maxi) and est_abr(n.droit, mini, maxi)]]> Erreur : les bornes sont transmises telles
quelles aux deux sous-arbres, sans jamais
être resserrées. Avec les bornes infinies
initiales, la condition
mini < n.valeur < maxi reste toujours
vraie : la fonction renvoie True pour
n'importe quel arbre binaire.

]]> def est_abr(n, mini=float('-inf'), maxi=float('inf')): if n is None: return True if not (mini < n.valeur < maxi): return False return est_abr(n.gauche, mini, n.valeur) and est_abr(n.droit, n.valeur, maxi)]]> Bonne réponse : on transmet à chaque
appel récursif les bornes que la valeur
du sous-arbre doit respecter. À gauche,
on resserre la borne supérieure ; à
droite, la borne inférieure. C'est le
schéma correct qui détecte aussi les
violations « profondes » (par exemple,
un nœud lointain qui violerait l'ordre).

]]> def est_abr(n): if n is None: return True return parcours_prefixe(n) == sorted(parcours_prefixe(n))]]> Erreur : seul le parcours infixe d'un
ABR est trié. Le parcours préfixe commence
par la racine, donc un ABR ordinaire
(racine $10$, fils gauche $5$) est déclaré
invalide, alors qu'une simple chaîne de
fils droits est acceptée. Même avec le
parcours infixe, cette approche coûterait
un tri en $O(n \log n)$, contre $O(n)$
pour la version à bornes.

]]> Arbres binaires de recherche — Q28 : Minimum et maximum dans un ABR Comment trouver respectivement le minimum
et le maximum d'un arbre binaire de
recherche non vide ?

]]> Cette propriété rejoint le parcours infixe : dans un arbre binaire de recherche, le minimum est la première clé affichée par ce parcours et le maximum la dernière.

]]> 1.0 0.0 0 true true abc Le minimum est toujours la racine, le
maximum est toujours une feuille

]]> Erreur : la racine est la première valeur insérée, pas le minimum. Le
minimum est dans le sous-arbre le plus à
gauche. Quant au maximum, il peut être
n'importe où à droite, pas forcément une
feuille.

]]> On parcourt tout l'arbre et on retient les
valeurs minimale et maximale au fur et à
mesure

]]> Cette méthode fonctionne (en $O(n)$) mais
ignore la propriété d'ordre. Avec
l'arbre binaire de recherche, on peut
faire bien mieux en descendant
directement à gauche ou à droite, en
$O(h)$.

]]> Le minimum tout à gauche, le maximum tout à droite, en $O(h)$

]]> Bonne réponse : par la propriété d'ordre,
tous les nœuds plus petits qu'un nœud
donné sont à sa gauche. En descendant
systématiquement à gauche jusqu'à
atteindre une feuille (sans enfant
gauche), on trouve la plus petite valeur.
Symétriquement à droite pour le maximum.

]]> Le minimum et le maximum sont les deux
enfants de la racine

]]> Erreur : seul l'enfant gauche direct
de la racine peut être plus petit qu'elle,
pas un éventuel descendant plus profond.
Et symétriquement à droite. La descente
jusqu'au bout est nécessaire.

]]> Arbres binaires de recherche — Q29 : Le nombre de niveaux minimal pour ranger des clés Combien de niveaux, au minimum, un arbre binaire de recherche
doit-il avoir pour contenir $15$ clés ?

]]> Avec $k$ niveaux pleins, un arbre contient $2^k - 1$ clés : le
nombre minimal de niveaux croît comme $\log_2 n$.

]]> 1.0 0.0 0 true true abc $4$, en remplissant chaque niveau

]]> Bonne réponse : $4$ niveaux pleins contiennent
$2^{4} - 1 = 15$ nœuds, juste ce qu'il faut. C'est la
forme équilibrée, qui donne une recherche en $\log_2 n$.

]]> $7$, la moitié des clés environ

]]> Erreur : chaque niveau peut contenir le double du précédent,
les niveaux sont bien moins nombreux.

]]> $5$, un niveau de plus pour la racine

]]> Erreur : la racine occupe le premier niveau, déjà compté.

]]> $15$, une clé à chaque niveau

]]> Erreur : c'est le pire cas, l'arbre filiforme, pas le minimum.

]]> Arbres binaires de recherche — Q30 : Le coût total d'insertions dans l'ordre croissant On insère les clés $1, 2, \ldots, 10$ dans cet ordre dans un
arbre binaire de recherche vide. Chaque insertion compare la
nouvelle clé à chaque nœud du chemin parcouru. Combien de
comparaisons en tout ?

]]> Les clés triées sont le pire ordre d'insertion : l'arbre dégénère
en liste et le coût cumulé devient quadratique.

]]> 1.0 0.0 0 true true abc $45$, soit $0 + 1 + \cdots + 9$

]]> Bonne réponse : l'arbre devient une chaîne ; la $k$-ième clé
descend le long des $k - 1$ nœuds déjà présents. Le total est
$10 \times 9 / 2 = 45$, de l'ordre de $n^2$.

]]> $10$, une seule par insertion

]]> Erreur : chaque insertion coûte autant de comparaisons que de
nœuds sur son chemin, pas une seule.

]]> $100$, soit $n$ par insertion

]]> Erreur : la $k$-ième insertion ne compare qu'avec $k - 1$
nœuds, pas $n$.

]]> $9$, une par nœud déjà présent

]]> Erreur : $9$ est le coût de la dernière insertion seulement.

]]> Arbres binaires de recherche — Q31 : L'intérêt de rééquilibrer un arbre Certaines bibliothèques rééquilibrent l'arbre binaire de recherche
après chaque insertion, au prix d'un travail supplémentaire.
Qu'y gagne-t-on ?

]]> Les coûts logarithmiques d'un arbre binaire de recherche supposent
un arbre équilibré ; le garantir a un prix à chaque insertion.

]]> 1.0 0.0 0 true true abc Une hauteur en $\log n$, quel que soit l'ordre des insertions

]]> Bonne réponse : sans rééquilibrage, des clés insérées dans
l'ordre dégradent l'arbre en liste ; le rééquilibrage maintient
toutes les opérations en $\log n$.

]]> La possibilité de ranger des clés en double sans conflit

]]> Erreur : les doublons relèvent d'une convention, pas de
l'équilibre.

]]> Un parcours infixe plus rapide, en $\log n$ au lieu de $n$

]]> Erreur : le parcours infixe visite tous les nœuds, il reste en
$n$ quelle que soit la forme.

]]> Une mémoire réduite, les nœuds étant rangés plus serrés

]]> Erreur : le nombre de nœuds ne change pas, la mémoire non
plus.

]]> Arbres binaires de recherche — Q32 : L'ordre d'insertion et la forme de l'arbre Deux programmes insèrent les mêmes clés dans un arbre binaire de
recherche vide, mais dans des ordres différents. Obtiennent-ils le
même arbre ?

]]> Un arbre binaire de recherche garde la trace de l'ordre dans lequel
il a été construit ; seul le parcours infixe en est indépendant.

]]> 1.0 0.0 0 true true abc Pas forcément, l'ordre d'insertion détermine la forme

]]> Bonne réponse : la première clé devient la racine, et chaque
suivante se place sous les précédentes. Les clés $1, 2, 3$
donnent une chaîne ; $2, 1, 3$ donnent un arbre équilibré.

]]> Oui, un ensemble de clés donne toujours le même arbre

]]> Erreur : seul le parcours infixe est le même ; la forme dépend
de l'ordre.

]]> Non, jamais, deux ordres donnant deux arbres distincts

]]> Erreur : deux ordres différents peuvent donner le même arbre,
par exemple $2, 1, 3$ et $2, 3, 1$.

]]> Oui, à condition que les clés soient des entiers

]]> Erreur : le type des clés ne change rien.

]]> Arbres binaires de recherche — Q33 : Le coût de la recherche du minimum Pour trouver la plus petite clé d'un arbre binaire de recherche,
on descend à gauche tant que possible. Quel est le coût de cette
recherche ?

]]> Le coût des opérations d'un arbre binaire de recherche se lit sur
sa hauteur, et la hauteur dépend de l'équilibre.

]]> 1.0 0.0 0 true true abc Proportionnel à la hauteur, de $\log n$ à $n$ selon la forme

]]> Bonne réponse : on suit une seule branche, la plus à gauche ; sa
longueur est au plus la hauteur, logarithmique si l'arbre est
équilibré, linéaire s'il est filiforme.

]]> Constant, le minimum étant toujours à la racine de l'arbre

]]> Erreur : la racine est la première clé insérée, pas la plus
petite.

]]> Toujours en $\log n$, quelle que soit la forme de l'arbre

]]> Erreur : dans un arbre filiforme penché à gauche, la branche
gauche contient tous les nœuds.

]]> Toujours en $n$, tous les nœuds devant être comparés

]]> Erreur : inutile de visiter les sous-arbres droits, qui ne
contiennent que des clés plus grandes.

]]> Arbres binaires de recherche — Q34 : Les sous-arbres d'un arbre binaire de recherche Le sous-arbre droit d'un arbre binaire de recherche est-il
lui-même un arbre binaire de recherche ?

]]> La définition récursive d'un arbre binaire de recherche impose la
propriété à chaque nœud : chaque sous-arbre la satisfait.

]]> 1.0 0.0 0 true true abc Oui, tout sous-arbre d'un arbre binaire de recherche en est un

]]> Bonne réponse : la propriété d'ordre s'applique à chaque nœud,
donc à la racine du sous-arbre droit comme à toutes les autres.
C'est ce qui permet les algorithmes récursifs.

]]> Non, seul l'arbre entier respecte la propriété d'ordre

]]> Erreur : la propriété est locale à chaque nœud, elle vaut dans
tout sous-arbre.

]]> Oui, sauf s'il est réduit à une feuille, qui n'a pas d'ordre

]]> Erreur : une feuille est un arbre binaire de recherche à un
seul nœud.

]]> Non, ses clés étant toutes plus grandes que la racine

]]> Erreur : être plus grandes que la racine n'empêche pas ces
clés d'être ordonnées entre elles.

]]> Arbres binaires de recherche — Q35 : Une clé mal placée malgré l'ordre local La racine porte $8$, son fils gauche porte $3$, et ce fils
gauche a pour fils droit $9$. Cet arbre est-il un arbre binaire
de recherche ?

]]> La propriété d'ordre est globale : toutes les clés du sous-arbre
gauche sont inférieures à la racine, toutes celles du droit
supérieures.

]]> 1.0 0.0 0 true true abc Non, $9$ est dans le sous-arbre gauche de $8$ mais lui est supérieur

]]> Bonne réponse : $9 > 3$, l'ordre local est respecté, mais
toute clé du sous-arbre gauche de $8$ doit être inférieure à
$8$. La propriété porte sur des sous-arbres entiers, pas
seulement sur les enfants directs.

]]> Oui, chaque enfant droit étant plus grand que son parent direct

]]> Erreur : vérifier chaque nœud avec son seul parent ne suffit
pas.

]]> Non, $3$ ne devrait pas avoir d'enfant droit, seulement un gauche

]]> Erreur : un enfant droit de $3$ est permis, à condition d'être
compris entre $3$ et $8$.

]]> Non, $8$ devrait être la plus petite clé, étant la racine

]]> Erreur : la racine n'a aucune raison d'être la plus petite
clé.

]]> Arbres binaires de recherche — Q36 : Le nombre d'arbres binaires de recherche possibles Combien d'arbres binaires de recherche différents peut-on former
avec les clés $1$ à $3$ ?

]]> Le nombre $C(n)$ d'arbres binaires de recherche à $n$ clés vérifie
$C(n) = C(0)C(n-1) + C(1)C(n-2) + \cdots + C(n-1)C(0)$, selon la
racine choisie : $1, 2, 5, 14, 42, \ldots$

]]> 1.0 0.0 0 true true abc $5$, en distinguant selon la racine

]]> Bonne réponse : on choisit la racine, puis une forme pour les
clés plus petites et une pour les plus grandes : deux formes avec $1$ à la racine, une avec $2$, deux avec $3$, soit
$5$.

]]> $6$, un par ordre d'insertion

]]> Erreur : des ordres d'insertion différents peuvent donner le
même arbre.

]]> $3$, un par choix de racine

]]> Erreur : une fois la racine choisie, les sous-arbres ont encore
plusieurs formes.

]]> $4$, un par répartition gauche ou droite

]]> Erreur : la place d'une clé n'est pas un simple choix gauche
ou droite indépendant des autres.

]]> Arbres binaires de recherche — Q37 : Le parcours droite, nœud, gauche Sur un arbre binaire de recherche, on parcourt récursivement le
sous-arbre droit, puis le nœud, puis le sous-arbre gauche.
Qu'obtient-on ?

]]> Inverser gauche et droite dans le parcours infixe inverse l'ordre
de sortie des clés.

]]> 1.0 0.0 0 true true abc Les clés dans l'ordre décroissant

]]> Bonne réponse : c'est le parcours infixe inversé ; les clés les
plus grandes, à droite, sortent en premier.

]]> Les clés dans l'ordre croissant

]]> Erreur : l'ordre croissant vient du parcours gauche, nœud,
droit.

]]> Les clés dans l'ordre d'insertion

]]> Erreur : aucun parcours ne restitue l'ordre d'insertion.

]]> Les feuilles seulement, de droite à gauche

]]> Erreur : tous les nœuds sont visités, pas seulement les
feuilles.

]]> Arbres binaires de recherche — Q38 : Une recherche écrite avec une boucle Quelle ligne complète cette recherche itérative de x dans un
arbre binaire de recherche de nœuds Noeud ?
def contient(racine, x):
    noeud = racine
    while noeud is not None:
        if x == noeud.valeur:
            return True
        # ligne à compléter
    return False

]]> La version itérative suit le même chemin que la version récursive,
en remplaçant l'appel par une mise à jour de noeud.

]]> 1.0 0.0 0 true true abc noeud = noeud.gauche if x < noeud.valeur else noeud.droit

]]> Bonne réponse : une clé plus petite ne peut être qu'à gauche,
une plus grande qu'à droite ; on descend d'un niveau à chaque
tour.

]]> noeud = noeud.droit if x < noeud.valeur else noeud.gauche

]]> Erreur : les côtés sont inversés, la recherche manquerait les
clés présentes.

]]> noeud = noeud.gauche, la clé étant toujours à gauche

]]> Erreur : toujours descendre à gauche ne trouve que les clés de
la branche gauche.

]]> noeud = racine, pour repartir du haut à chaque tour

]]> Erreur : revenir à la racine ferait boucler sans fin.

]]> Arbres binaires de recherche — Q39 : Supprimer une feuille Comment supprimer une clé située sur une feuille d'un arbre
binaire de recherche, sans casser la propriété d'ordre ?

]]> La suppression d'une feuille est le cas simple ; la suppression
d'un nœud à deux enfants demande de le remplacer par une clé
voisine.

]]> 1.0 0.0 0 true true abc Remplacer par None le lien que son parent tient vers elle

]]> Bonne réponse : la feuille n'a pas d'enfant, la retirer ne
déplace aucune autre clé ; l'ordre des clés restantes est
inchangé.

]]> Remplacer sa valeur par celle de la racine, puis supprimer la racine

]]> Erreur : la valeur de la racine n'a rien à faire à cet endroit
de l'arbre.

]]> Décaler toutes les clés plus grandes d'un cran vers la gauche

]]> Erreur : un arbre n'est pas un tableau, rien ne se décale.

]]> Mettre sa valeur à None en laissant le nœud dans l'arbre

]]> Erreur : un nœud sans valeur fausserait les comparaisons et les
parcours.

]]> Arbres binaires de recherche — Q40 : Supprimer un nœud à deux enfants On veut supprimer une clé dont le nœud a deux enfants. Par quelle
clé la remplacer pour conserver la propriété d'ordre ?

]]> Le remplaçant doit être compris entre tout le sous-arbre gauche et
tout le sous-arbre droit : seuls le successeur et le prédécesseur
conviennent.

]]> 1.0 0.0 0 true true abc La plus petite clé de son sous-arbre droit

]]> Bonne réponse : cette clé est plus grande que tout le
sous-arbre gauche et plus petite que le reste du sous-arbre
droit ; elle prend la place sans rien déranger, et son ancien
nœud, qui n'a pas d'enfant gauche, s'enlève facilement. La plus
grande clé du sous-arbre gauche convient aussi.

]]> La clé de la racine, en descendant le reste

]]> Erreur : la racine n'est en général ni plus grande que le
sous-arbre gauche ni plus petite que le droit.

]]> N'importe quelle feuille de l'arbre, au choix

]]> Erreur : une feuille quelconque n'a aucune raison d'être
comprise entre les deux sous-arbres.

]]> La plus grande clé de son sous-arbre droit

]]> Erreur : elle serait plus grande que des clés restées dans le
sous-arbre droit.

]]> Arbres binaires de recherche — Q41 : La place d'une clé nouvellement insérée Où se retrouve une clé que l'on vient d'insérer dans un arbre
binaire de recherche, par l'algorithme habituel ?

]]> L'insertion ne modifie jamais la structure existante : elle ne
fait qu'ajouter une feuille.

]]> 1.0 0.0 0 true true abc Sur une nouvelle feuille, au bout du chemin de recherche

]]> Bonne réponse : l'insertion descend comme une recherche jusqu'à
un sous-arbre vide, et y crée un nœud sans enfant.

]]> À la racine, les autres nœuds descendant d'un niveau

]]> Erreur : la racine ne change jamais lors d'une insertion
simple.

]]> Entre deux nœuds existants, au milieu du chemin

]]> Erreur : aucun nœud n'est déplacé ni intercalé.

]]> À la place du nœud dont la clé est la plus proche

]]> Erreur : remplacer un nœud perdrait sa clé.

]]>