$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 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.

]]> Pour chaque nœud, toutes les valeurs du sous-arbre gauche sont strictement inférieures à la valeur du nœud, et toutes celles du sous-arbre droit lui sont strictement supérieures

]]> 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 la plus grande valeur de l'arbre

]]> Cette propriété correspond à la définition
d'un tas (de type maximum), pas à celle
d'un arbre binaire de recherche. Dans un
arbre binaire de recherche, 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²)

]]> 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 motive
l'utilisation d'arbres binaires de recherche
auto-équilibrés (de type AVL ou rouge-noir),
qui maintiennent une hauteur en O(\log n)
grâce à des opérations de rééquilibrage à
chaque insertion ou suppression.

]]> 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(\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²)

]]> 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), lorsque l'arbre a dégénéré en peigne et que chaque nœud n'a qu'un enfant

]]> 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 dans l'arbre en comparant la valeur avec chaque nœud rencontré, puis on l'insère comme nouvelle feuille à la place vide trouvée

]]> 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 : Suppression La suppression d'un nœud dans un arbre
binaire de recherche est plus délicate que
l'insertion. Pourquoi ?

]]> Le cas le plus délicat est celui d'un nœud à
deux enfants. Le successeur infixe se trouve
facilement : il s'agit du nœud le plus à
gauche dans le sous-arbre droit du nœud à
supprimer.

]]> 1.0 0.0 0 true true abc Parce qu'il faut détruire l'arbre puis le reconstruire entièrement

]]> Cette opération serait inutilement
coûteuse. La suppression peut se faire de
manière purement locale.

]]> Parce que selon que le nœud à supprimer a 0, 1 ou 2 enfants, le traitement est différent, et le cas à deux enfants demande de remplacer le nœud par son successeur (ou son prédécesseur)

]]> On distingue trois cas. Si le nœud est une
feuille, on le supprime simplement. S'il a
un seul enfant, on remplace le nœud par
cet enfant. S'il a deux enfants, on le
remplace par le successeur infixe
(plus petit du sous-arbre droit) ou par le
prédécesseur infixe (plus grand du
sous-arbre gauche), puis on supprime ce
successeur (qui a au plus un enfant).

]]> Parce qu'il faut entièrement re-trier l'arbre après chaque suppression

]]> Aucun tri global n'est nécessaire.
L'opération reste locale, mais doit
distinguer plusieurs cas selon la
structure du nœud supprimé.

]]> Parce qu'il est impossible de supprimer un nœud dans un arbre binaire de recherche

]]> La suppression est tout à fait possible.
Elle est simplement plus complexe que
l'insertion, en raison de la distinction
de cas.

]]> 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.

]]> L'insertion et la suppression y sont en O(\log n), alors qu'elles coûtent O(n) dans un tableau trié, à cause du décalage des éléments

]]> 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 insérée en dernier et
finit en feuille à gauche. La racine est
toujours la première valeur insérée.

]]> 4

]]> La valeur 4 est plus petite que 5
mais plus grande que 3. 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, de nombreuses bibliothèques
utilisent des arbres auto-équilibrés pour
implémenter des ensembles et dictionnaires
triés. C'est le cas par exemple de TreeSet
et TreeMap en Java, ou de std::set et
std::map en C++.

]]> 1.0 0.0 0 true true abc Maintenir dynamiquement un ensemble trié de valeurs avec des ajouts, des suppressions et des recherches fréquentes

]]> 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 des éléments d'une liste

]]> 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):
return v == n.valeur
`

]]> Cette fonction ne descend pas dans
l'arbre. Elle ne renvoie un résultat
correct que si la valeur cherchée est
exactement à la racine.

]]> `
def chercher(n, v):
return True
`

]]> Cette fonction renvoie toujours True,
sans effectuer la moindre recherche.
Elle est manifestement incorrecte.

]]> `
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 — Q11 : Arbres AVL Un arbre AVL est un arbre binaire de
recherche auto-équilibré. Quelle contrainte
maintient-il pour rester équilibré ?

]]> L'arbre AVL garantit, pour n nœuds, une
hauteur en O(\log n), et donc des
opérations en O(\log n). Le coût à payer
est l'effort de maintien (rotations) à
chaque insertion ou suppression.

]]> 1.0 0.0 0 true true abc Pour chaque nœud, les hauteurs des sous-arbres gauche et droit ne diffèrent jamais de plus de 1

]]> C'est la définition stricte d'un arbre
AVL. Lorsque cette propriété est violée
après une insertion, des rotations
rétablissent l'équilibre. Les arbres AVL
ont été inventés par Adelson-Velsky et
Landis en 1962.

]]> Tous les chemins de la racine aux feuilles ont la même longueur

]]> Cette contrainte définirait un arbre
parfait, beaucoup plus rigide qu'un
arbre AVL.

]]> Tous les sous-arbres doivent avoir la même taille

]]> La contrainte porte sur la hauteur des
sous-arbres, et non sur leur taille en
nombre de nœuds.

]]> La racine doit toujours être la valeur médiane des valeurs présentes

]]> Maintenir la médiane à la racine après
chaque opération serait beaucoup trop
coûteux. Ce n'est pas la stratégie
adoptée par les arbres AVL.

]]> Arbres binaires de recherche — Q12 : Arbres rouge-noir Les arbres rouge-noir sont une autre famille
d'arbres binaires de recherche
auto-équilibrés. Quelle est leur particularité
par rapport aux arbres AVL ?

]]> Les arbres rouge-noir sont à la base de
nombreuses bibliothèques standard (std::map
en C++, TreeMap en Java). Ils ont été
inventés en 1972 par Bayer, puis
généralisés par Sedgewick.

]]> 1.0 0.0 0 true true abc Ils n'autorisent que les insertions, et pas les suppressions

]]> Les arbres rouge-noir gèrent toutes les
opérations classiques : recherche,
insertion et suppression.

]]> Ils sont parfaitement équilibrés

]]> Ils sont en réalité moins strictement
équilibrés que les arbres AVL, mais avec
un coût d'équilibrage moindre.

]]> Ils utilisent un tri par tas en interne

]]> Les arbres rouge-noir n'ont aucun rapport
avec les tas, qui constituent une
structure de données différente.

]]> Ils tolèrent un déséquilibre légèrement supérieur (la hauteur reste majorée par 2 \log n), en échange d'opérations d'équilibrage moins fréquentes

]]> Ce compromis est intéressant en pratique.
Les arbres AVL sont plus rapides en
recherche, parce que plus plats, mais
plus coûteux à maintenir. Les arbres
rouge-noir équilibrent ces deux aspects.

]]> 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, deux solutions
classiques. On peut utiliser un arbre
auto-équilibré, ou bien mélanger les
insertions au préalable. C'est aussi la
motivation des arbres randomisés (treaps),
qui maintiennent l'équilibre grâce au
hasard.

]]> 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, par ordre croissant ou décroissant

]]> 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.
Avec n insertions en O(n \log n) amortis
et un parcours infixe en O(n), on obtient
un tri en O(n \log n), comparable à un
tri fusion ou à un tri rapide.

]]> 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 un 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, qui visite naturellement les valeurs en 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):
return Noeud(v)
`

]]> Cette fonction remplace l'arbre entier
par un seul nœud, perdant toutes les
valeurs précédemment insérées.

]]> `
def inserer(n, v):
n.valeur = v
return n
`

]]> Cette fonction écrase la valeur de la
racine au lieu d'ajouter un nœud. Elle
ne construit pas un arbre binaire de
recherche.

]]> `
def inserer(n, v):
n.gauche = Noeud(v)
return n
`

]]> Cette fonction insère toujours à gauche,
sans tenir compte de la valeur de v.
Elle viole donc systématiquement la
propriété d'ordre.

]]> 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 dans l'ordre du tableau

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

]]> Prendre l'élément du milieu comme racine, puis construire récursivement le sous-arbre gauche à partir de la moitié inférieure et le sous-arbre droit à partir de la moitié supérieure

]]> 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), preuve que la valeur n'est pas présente dans l'arbre

]]> À 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, 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 et l'enfant droit est plus grand. Il faut aussi vérifier que toutes les valeurs du sous-arbre gauche sont inférieures (et symétriquement pour le sous-arbre droit)

]]> 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 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 — Q19 : Comparaison avec une table de hachage Comparé à une table de hachage, quel est
l'avantage d'un arbre binaire de
recherche ?

]]> Le choix dépend du besoin. Pour des accès
par clé sans contrainte d'ordre, la table
de hachage est préférable. Pour maintenir
les valeurs en ordre ou répondre à des
requêtes par intervalle, l'arbre binaire de
recherche est mieux adapté.

]]> 1.0 0.0 0 true true abc Il maintient les éléments dans l'ordre, ce qui permet de répondre à des requêtes par intervalle ou de retrouver le voisin le plus proche

]]> Un arbre binaire de recherche permet de
répondre à des questions comme « tous
les éléments entre a et b » ou
« le plus petit élément supérieur ou égal
à v » en O(\log n). Une table de
hachage ne le permet pas.

]]> Il consomme moins de mémoire

]]> Cette affirmation n'est pas
systématiquement vraie. La consommation
mémoire dépend de l'implémentation des
deux structures.

]]> Il est plus simple à implémenter

]]> Au contraire, un arbre binaire de
recherche auto-équilibré est en
général plus complexe à implémenter
qu'une table de hachage.

]]> La recherche y est plus rapide

]]> C'est l'inverse. Une table de hachage
a une recherche en O(1) amorti, ce
qui est plus rapide que le O(\log n)
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 : Suppression d'un nœud à deux enfants Pour supprimer un nœud à deux enfants dans
un arbre binaire de recherche, par quoi le
remplace-t-on ?

]]> Le successeur infixe se trouve en
descendant une fois à droite, puis tout à
gauche. Cette opération s'effectue en
O(h) étapes au pire, où h est la
hauteur de l'arbre.

]]> 1.0 0.0 0 true true abc Par le sous-arbre gauche complet

]]> Déplacer un sous-arbre entier ne
conserverait pas la propriété d'ordre
de l'arbre.

]]> Par la racine de l'arbre

]]> Cette opération briserait toute la
structure de l'arbre.

]]> Par une feuille choisie au hasard

]]> Choisir une feuille au hasard violerait
la propriété d'ordre de l'arbre.

]]> Par son successeur infixe (le plus petit nœud du sous-arbre droit) ou par son prédécesseur infixe (le plus grand du sous-arbre gauche)

]]> Ce nœud est le plus proche du nœud
supprimé dans l'ordre des valeurs. Il a
forcément au plus un enfant (sinon, un
nœud encore plus à gauche existerait),
ce qui rend sa suppression simple. On
copie sa valeur dans le nœud à
supprimer, puis on supprime ce
successeur.

]]> Arbres binaires de recherche — Q22 : Hauteur attendue Pour un arbre binaire de recherche construit
en insérant n valeurs dans un ordre
aléatoire, quelle est la hauteur attendue ?

]]> Ce résultat justifie l'utilisation
d'arbres binaires de recherche non
auto-équilibrés lorsque l'on contrôle
l'ordre d'insertion (par exemple en
mélangeant les données au préalable). Les
structures auto-équilibrées garantissent
une complexité en O(\log n) même dans
le pire cas.

]]> 1.0 0.0 0 true true abc Θ(√n)

]]> Cette croissance ne correspond pas au
comportement asymptotique de la
hauteur d'un arbre binaire de
recherche.

]]> Θ(n)

]]> Cette hauteur correspond au pire cas
(insertion dans un ordre déjà trié) et
non au cas moyen. Avec un ordre
aléatoire, le résultat est bien
meilleur.

]]> \Theta(\log n)

]]> C'est un résultat classique. En
espérance (sur l'ordre aléatoire
d'insertion), la hauteur est en
\Theta(\log n). Toutes les opérations
ont alors une complexité moyenne en
O(\log n), sans qu'aucun équilibrage
explicite soit nécessaire.

]]> Θ(1)

]]> La hauteur d'un arbre croît
nécessairement avec le nombre de
valeurs n. Elle ne peut pas rester
constante.

]]> 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 en pratique le tri
fusion (toujours en O(n \log n)
garanti) ou le tri rapide (souvent en
O(n \log n) avec un bon choix de
pivot).

]]> 1.0 0.0 0 true true abc O(n!)

]]> Cette complexité factorielle est
encore plus excessive et ne correspond
à aucun algorithme de tri raisonnable.

]]> O(n \log n) en moyenne (avec un ordre aléatoire), mais O(n²) dans le pire cas (ordre déjà trié)

]]> 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²).

]]> O(n)

]]> Insérer n valeurs dans une structure
ordonnée ne peut pas se faire en
O(n). Tout tri par comparaisons est
au moins en \Omega(n \log n).

]]> O(2ⁿ)

]]> Cette complexité exponentielle n'a
aucune raison d'apparaître dans un
tri.

]]> Arbres binaires de recherche — Q24 : Successeur d'un nœud Étant donné un nœud n dans un arbre binaire
de recherche, comment trouver son
successeur infixe, c'est-à-dire la valeur
immédiatement supérieure ?

]]> Cette logique permet d'implémenter un
itérateur sur un arbre binaire de
recherche, qui produit les valeurs en
ordre croissant sans stockage
supplémentaire (à part une pile implicite
pour remonter dans l'arbre).

]]> 1.0 0.0 0 true true abc La racine de l'arbre est toujours le successeur

]]> Cette description est trop simpliste
et incorrecte. Le successeur d'un
nœud n'est pas en général la racine.

]]> En descendant toujours à gauche

]]> Cette stratégie n'est pas systématique.
Le successeur peut très bien se trouver
ailleurs dans l'arbre.

]]> Le successeur est choisi au hasard parmi les autres nœuds

]]> La détermination du successeur est
strictement déterministe : aucun
hasard n'intervient.

]]> Si le nœud n a un sous-arbre droit, son successeur est le nœud le plus à gauche de ce sous-arbre. Sinon, c'est le premier ancêtre dont n se trouve dans le sous-arbre gauche

]]> C'est la définition correcte. En
parcourant ainsi, on visite l'arbre
dans l'ordre infixe sans utiliser la
récursion, ce qui est très pratique
pour implémenter un itérateur.

]]> 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
auto-équilibré 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 Implémenter un dictionnaire dont les clés sont triées dynamiquement, avec des recherches par intervalle fréquentes

]]> C'est exactement le cas d'usage des
arbres binaires de recherche
auto-équilibrés. Cette structure
permet, en O(\log n), de répondre à
des requêtes comme « les clés entre
a et b » ou « la plus petite clé
supérieure ou égale à v ».

]]> Calculer la somme des é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, les algorithmes de tri
classiques (tri fusion, tri rapide)
sont plus simples et tout aussi
efficaces.

]]> 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 ; sous-arbre gauche : 5 avec
3 à gauche et 7 à droite ; sous-arbre
droit : 15 avec 12 à gauche

]]> 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 première option, qui 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):
return n is None
`

]]> Erreur : cette fonction renvoie True
uniquement pour l'arbre vide, et False
pour tout arbre non vide, ce qui est
manifestement faux.

]]> `
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_infixe(n) == sorted(parcours_infixe(n))
`

]]> Cette approche est correcte mais
inefficace : elle nécessite un parcours
complet, un tri en O(n \log n) et une
comparaison. La version récursive avec
bornes est en O(n) et plus élégante.

]]> 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é est exploitée dans la
suppression d'un nœud à deux enfants : on
remplace le nœud par son successeur
infixe (le minimum de son sous-arbre droit)
ou son prédécesseur infixe (le maximum de
son sous-arbre gauche), tous deux trouvables
en O(h).

]]> 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 se trouve en descendant toujours
à gauche depuis la racine ; le maximum
en descendant toujours à droite. Les
deux opérations sont en O(h) où h est
la hauteur

]]> 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.

]]>