$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
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.]]>
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.]]>
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.]]>
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)]]>
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é.]]>
O(n²)]]>
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.]]>
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(√n)]]>
Aucune raison particulière n'amène à une
complexité de cette forme dans un arbre
binaire de recherche.]]>
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.]]>
O(n²), 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(\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é.]]>
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 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.]]>
Les valeurs dans un ordre aléatoire]]>
Un parcours d'arbre est strictement
déterministe : il ne fait jamais appel au
hasard.]]>
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 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.]]>
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 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 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.]]>
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, 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.]]>
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, 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.]]>
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.]]>
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
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.]]>
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).]]>
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.]]>
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
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.]]>
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.]]>
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
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.]]>
Afficher une image]]>
L'affichage d'une image n'a aucun rapport
avec la structure d'arbre binaire de
recherche.]]>
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.]]>
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
`python
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.]]>
`python
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.]]>
`python
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).]]>
`python
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é.]]>
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 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).]]>
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 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 une seule valeur]]>
Un arbre composé d'un seul nœud ne pose
évidemment aucun problème de
dégénérescence.]]>
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.]]>
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é.]]>
Ne renvoyer que les feuilles de l'arbre]]>
On perdrait alors toutes les valeurs des
nœuds internes, ce qui est manifestement
incorrect.]]>
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
`python
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.]]>
`python
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).]]>
`python
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.]]>
`python
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é.]]>
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 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.]]>
Insérer les éléments dans un ordre aléatoire]]>
Cette approche donne un arbre presque
équilibré en moyenne, mais sans aucune
garantie absolue.]]>
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
À 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.]]>
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).]]>
À 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.]]>
À 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.]]>
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.]]>
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.]]>
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.]]>
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
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.]]>
8, 5, 3, 2, 1 (ordre décroissant)]]>
Cette séquence correspond au parcours
infixe inversé, et non au parcours
infixe standard.]]>
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.]]>
5, 2, 1, 3, 8 (parcours préfixe)]]>
Cette séquence correspond au parcours
préfixe (racine, gauche, droite),
et non au parcours infixe.]]>
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.]]>
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.]]>
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.]]>
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(2ⁿ), 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.]]>
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(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²) 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²).]]>
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
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.]]>
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.]]>
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.]]>
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
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.]]>
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é.]]>
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.]]>
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
`python
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.]]>
`python
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.]]>
`python
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.]]>
`python
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).]]>
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.]]>
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.]]>
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.]]>
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).]]>
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ᵏ - 1 clés : le
nombre minimal de niveaux croît comme \log_2 n.]]>
1.0
0.0
0
true
true
abc
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.]]>
4, en remplissant chaque niveau]]>
Bonne réponse : 4 niveaux pleins contiennent
2⁴ - 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.]]>
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 + ·s + 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 × 9 / 2 = 45, de l'ordre de n².]]>
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
La possibilité de ranger des clés en double sans conflit]]>
Erreur : les doublons relèvent d'une convention, pas de
l'équilibre.]]>
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.]]>
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.]]>
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.]]>
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
Oui, à condition que les clés soient des entiers]]>
Erreur : le type des clés ne change rien.]]>
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.]]>
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é.]]>
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
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.]]>
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.]]>
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.]]>
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.]]>
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, 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, 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.]]>
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.]]>
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.]]>
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, 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, 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.]]>
Non, 8 devrait être la plus petite clé, étant la racine]]>
Erreur : la racine n'a aucune raison d'être la plus petite
clé.]]>
Oui, chaque enfant droit étant plus grand que son parent direct]]>
Erreur : vérifier chaque nœud avec son seul parent ne suffit
pas.]]>
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) + ·s + C(n-1)C(0), selon la
racine choisie : 1, 2, 5, 14, 42, \ldots]]>
1.0
0.0
0
true
true
abc
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.]]>
3, un par choix de racine]]>
Erreur : une fois la racine choisie, les sous-arbres ont encore
plusieurs formes.]]>
6, un par ordre d'insertion]]>
Erreur : des ordres d'insertion différents peuvent donner le
même arbre.]]>
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.]]>
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 croissant]]>
Erreur : l'ordre croissant vient du parcours gauche, nœud,
droit.]]>
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 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 ?
`python
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, 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.]]>
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 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.]]>
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
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.]]>
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é.]]>
Mettre sa valeur à None en laissant le nœud dans l'arbre]]>
Erreur : un nœud sans valeur fausserait les comparaisons et les
parcours.]]>
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.]]>
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 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.]]>
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 plus grande clé de son sous-arbre droit]]>
Erreur : elle serait plus grande que des clés restées dans le
sous-arbre 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.]]>
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
À la racine, les autres nœuds descendant d'un niveau]]>
Erreur : la racine ne change jamais lors d'une insertion
simple.]]>
À la place du nœud dont la clé est la plus proche]]>
Erreur : remplacer un nœud perdrait sa clé.]]>
Entre deux nœuds existants, au milieu du chemin]]>
Erreur : aucun nœud n'est déplacé ni intercalé.]]>
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.]]>