$course$/QCM de NSI/Terminale/Arbres binaires Définition d'un arbre binaire (nœuds, racine, feuilles,
sous-arbres), terminologie (hauteur, profondeur, taille),
parcours en profondeur (préfixe, infixe, postfixe) et en
largeur, propriétés des arbres équilibrés et complets,
applications.

]]> Arbres binaires — Q01 : Définition d'un arbre binaire Qu'est-ce qu'un arbre binaire ?

]]> Vocabulaire : racine (sommet), nœud interne
(au moins un enfant), feuille (aucun enfant),
sous-arbre (arbre formé par un nœud et ses
descendants). Cette définition est fondamentale.

]]> 1.0 0.0 0 true true abc Une structure linéaire avec deux pointeurs par élément

]]> Erreur : c'est plutôt une liste doublement
chaînée. Un arbre n'est pas linéaire mais
hiérarchique.

]]> Une structure hiérarchique où chaque nœud a au plus deux enfants

]]> Bonne réponse : un arbre binaire est un cas
particulier d'arbre où chaque nœud a 0, 1 ou
2 enfants. La structure est récursive : chaque
enfant est lui-même la racine d'un arbre binaire.

]]> Un arbre généalogique classique des liens de parenté

]]> Erreur : un arbre généalogique n'est pas
forcément binaire (chaque personne a au plus
deux parents directs, mais peut avoir plus de
deux enfants).

]]> Un arbre dont chaque nœud contient exactement deux valeurs numériques distinctes

]]> Erreur : « binaire » fait référence au nombre
d'enfants, pas au nombre de valeurs par nœud.

]]> Arbres binaires — Q02 : Racine Combien de racines un arbre binaire possède-t-il ?

]]> L'unicité de la racine définit l'arbre. Si on a
plusieurs « racines », on parle plutôt d'une
forêt (ensemble disjoint d'arbres).

]]> 1.0 0.0 0 true true abc Plusieurs, autant que de feuilles

]]> Erreur : confusion entre racine et feuille. Un
arbre a une racine et plusieurs feuilles
(typiquement).

]]> Aucune

]]> Erreur : un arbre non vide a toujours exactement
une racine. Seul l'arbre vide n'a pas de racine.

]]> Cela dépend de la profondeur

]]> Erreur : non, peu importe la profondeur, il y a
toujours une seule racine.

]]> Exactement une

]]> Bonne réponse : la racine est le sommet de
l'arbre, le nœud sans parent. Tout autre nœud
descend de la racine via une chaîne unique.

]]> Arbres binaires — Q03 : Feuille Qu'est-ce qu'une feuille dans un arbre binaire ?

]]> Les feuilles sont importantes car elles marquent les
cas de base des algorithmes récursifs sur les arbres.
Un parcours s'arrête typiquement à chaque feuille.

]]> 1.0 0.0 0 true true abc Un nœud qui a exactement deux enfants

]]> Erreur : ça, c'est un nœud interne complet.
Une feuille n'a aucun enfant.

]]> Un nœud qui n'a aucun enfant

]]> Bonne réponse : une feuille est un nœud sans
descendant. Elle marque la fin d'une branche.

]]> La racine de l'arbre

]]> Erreur : la racine est au sommet, les feuilles
sont les nœuds terminaux.

]]> Un nœud à mi-hauteur de l'arbre

]]> Erreur : aucune définition de feuille basée sur
la hauteur.

]]> Arbres binaires — Q04 : Hauteur d'un arbre Qu'appelle-t-on hauteur d'un arbre binaire ?

]]> Variante : certaines conventions comptent en
nombre de nœuds plutôt que d'arêtes (la racine
seule a alors une hauteur de 1). Préciser la
convention dans tout exercice.

]]> 1.0 0.0 0 true true abc La distance maximale séparant deux feuilles quelconques de l'arbre

]]> Erreur : c'est le diamètre, pas la hauteur.

]]> Le plus long chemin de la racine à une feuille

]]> Bonne réponse : convention courante, en
comptant le chemin en nombre d'arêtes. Un
arbre réduit à une racine a une hauteur de
0. Un arbre vide a souvent la convention de
hauteur -1.

]]> Le nombre total de nœuds que contient l'arbre

]]> Erreur : c'est la taille, pas la hauteur.

]]> Le nombre de feuilles présentes dans tout l'arbre

]]> Le nombre de feuilles
renseigne sur la
capacité finale d'un
arbre, mais ne mesure
pas sa hauteur.

]]> Arbres binaires — Q05 : Profondeur d'un nœud La profondeur d'un nœud dans un arbre est :

]]> La hauteur de l'arbre est égale à la profondeur
maximale (parmi tous les nœuds). Les deux notions
sont liées mais distinctes.

]]> 1.0 0.0 0 true true abc Le nombre total de descendants de ce nœud

]]> Erreur : c'est plutôt la taille du sous-arbre
enraciné en ce nœud.

]]> La longueur du chemin de la racine jusqu'à ce nœud

]]> Bonne réponse : la racine a une profondeur de
0, ses enfants 1, etc. La profondeur est une
propriété du nœud, alors que la hauteur est une
propriété de l'arbre.

]]> La distance de ce nœud jusqu'à sa feuille la plus proche

]]> Erreur : pas la définition standard de
profondeur.

]]> Le nombre de feuilles situées sous ce nœud

]]> Erreur : c'est encore une autre quantité.

]]> Arbres binaires — Q06 : Parcours préfixe Dans un parcours préfixe (ou pre-order), dans
quel ordre visite-t-on les nœuds ?

]]> Mnémotechnique : préfixe = nœud d'abord ;
infixe = nœud au milieu ; postfixe = nœud après. Le « préfixe », « infixe », « postfixe »
réfère à la position du nœud dans la séquence des
visites.

]]> 1.0 0.0 0 true true abc Sous-arbre gauche, sous-arbre droit, nœud

]]> Erreur : c'est le parcours postfixe
(post-order).

]]> Sous-arbre gauche, nœud, sous-arbre droit

]]> Erreur : c'est le parcours infixe (in-order).

]]> Sous-arbre droit, nœud, sous-arbre gauche

]]> Erreur : ordre inhabituel, ce n'est aucun des
parcours classiques.

]]> Nœud, sous-arbre gauche, sous-arbre droit

]]> Bonne réponse : « préfixe » car on visite le nœud
avant ses enfants (préfixe = devant).
Utilisation typique : copier un arbre.

]]> Arbres binaires — Q07 : Parcours infixe Dans quel ordre s'effectue un parcours infixe d'un
arbre binaire ?

]]> Sur un arbre binaire de recherche, le parcours
infixe parcourt les valeurs dans l'ordre. C'est la
raison principale d'utiliser cette structure pour
maintenir un ensemble trié dynamiquement.

]]> 1.0 0.0 0 true true abc Toutes les feuilles d'abord, puis tous les nœuds internes

]]> Erreur : aucun parcours classique ne sépare
ainsi.

]]> Sous-arbre gauche, nœud, sous-arbre droit

]]> Bonne réponse : on visite d'abord tout le
sous-arbre gauche, puis le nœud lui-même, puis le
sous-arbre droit. Ce parcours est très utile sur
un arbre binaire de recherche : il donne les
valeurs dans l'ordre croissant.

]]> Sous-arbre gauche, sous-arbre droit, nœud

]]> Erreur : c'est le parcours postfixe.

]]> Nœud, sous-arbre gauche, sous-arbre droit

]]> Erreur : c'est le parcours préfixe.

]]> Arbres binaires — Q08 : Parcours postfixe Le parcours postfixe visite :

]]> Application : pour calculer la taille d'un arbre
ou sa hauteur récursivement, on a besoin des
résultats des sous-arbres avant le nœud courant,
c'est typiquement un parcours postfixe.

]]> 1.0 0.0 0 true true abc D'abord le nœud courant, puis son sous-arbre gauche, puis son sous-arbre droit

]]> Erreur : c'est le parcours préfixe.

]]> Le sous-arbre gauche, puis le sous-arbre droit, puis le nœud

]]> Bonne réponse : on visite le nœud après ses
enfants. Très utile pour libérer la mémoire d'un
arbre (ses feuilles d'abord) ou évaluer une
expression arithmétique en notation postfixée.

]]> Uniquement les feuilles, en ignorant les nœuds internes

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

]]> Les nœuds dans un ordre aléatoire, différent à chaque appel

]]> Erreur : un parcours est déterministe.

]]> Arbres binaires — Q09 : Parcours en largeur Le parcours en largeur d'un arbre :

]]> Mémo : largeur = file, profondeur = pile
(ou récursivité). Cette dualité est centrale dans
les algorithmes sur les graphes, dont les
parcours en largeur et en profondeur s'appuient
sur ces deux structures.

]]> 1.0 0.0 0 true true abc Visite uniquement les nœuds internes, sans passer par les feuilles

]]> Erreur : tous les nœuds sont visités.

]]> Évalue une expression arithmétique stockée dans l'arbre

]]> Erreur : ce serait plutôt un parcours postfixe.

]]> Visite tous les nœuds à profondeur 0, puis 1, puis 2, etc.

]]> Bonne réponse : on parcourt niveau par niveau,
de la racine vers les feuilles. Implémentation
standard : avec une file.

]]> Visite la branche gauche en entier avant la droite

]]> Erreur : c'est plutôt un parcours en
profondeur orienté vers la gauche.

]]> Arbres binaires — Q10 : Taille d'un arbre La taille d'un arbre binaire est :

]]> Relation utile : un arbre binaire de hauteur h a
au plus 2ʰ⁺¹ - 1 nœuds. C'est le nombre maximum,
atteint quand l'arbre est parfait (tous les niveaux
entièrement remplis, toutes les feuilles au même niveau).

]]> 1.0 0.0 0 true true abc La hauteur du plus long chemin

]]> Erreur : c'est la hauteur, pas la taille.

]]> Le nombre d'arêtes

]]> Erreur : un arbre à n nœuds a exactement
n - 1 arêtes, donc ce n'est pas une mesure
indépendante.

]]> Le nombre de feuilles

]]> Erreur : c'est seulement une partie des nœuds.

]]> Le nombre total de nœuds

]]> Bonne réponse : la taille compte tous les nœuds
(internes et feuilles). Pour la calculer, un
parcours récursif suffit : T(\text{vide}) = 0 ;
T(\text{nœud}) = 1 + T(\text{gauche}) + T(\text{droit}).

]]> Arbres binaires — Q11 : Implémentation Python Pour un nœud d'arbre binaire, l'implémentation la plus
claire et la plus idiomatique en Python est :

]]> Convention : un sous-arbre vide est représenté par
None. Cela simplifie la récursivité, le cas de
base est if noeud is None: return ....

]]> 1.0 0.0 0 true true abc Une liste de longueur fixe [valeur, gauche, droite]

]]> Erreur : possible, mais peu lisible. Une classe
dédiée est plus claire.

]]> Un dictionnaire unique associant une clé entière à chaque nœud

]]> Erreur : possible mais pas idiomatique. Une
classe dédiée est plus claire.

]]> Une classe avec trois attributs : valeur, gauche, droit

]]> Bonne réponse : c'est l'approche orientée objet
standard, où gauche et droit valent soit
None, soit un autre nœud. Exemple :

`python
class Noeud:
def __init__(self, v, g=None, d=None):
self.valeur = v
self.gauche = g
self.droit = d
`

]]> Une chaîne de caractères listant les valeurs des nœuds

]]> Erreur : pas adapté à une structure récursive.

]]> Arbres binaires — Q12 : Calcul récursif de la hauteur Quelle fonction Python calcule correctement la hauteur
d'un arbre binaire (en nombre d'arêtes, -1 pour l'arbre
vide) ?

]]> Convention alternative : compter en nombre de nœuds sur le chemin (cas vide → 0). Adapter
l'arithmétique en conséquence (\max + 1 devient
\max ou différent).

]]> 1.0 0.0 0 true true abc `python
def h(n):
if n is None: return -1
return 1 + max(h(n.gauche), h(n.droit))
`

]]> Bonne réponse : on prend la profondeur maximale
des deux sous-arbres et on ajoute 1 (pour
l'arête vers ce nœud). Convention : arbre vide
de hauteur -1, racine seule de hauteur 0.

]]> `python
def h(n):
if n is None: return 0
return 1 + h(n.gauche) + h(n.droit)
`

]]> Erreur : on somme les hauteurs, ce qui est
incorrect. Il faut prendre le maximum.

]]> `python
def h(n):
if n is None: return -1
return max(h(n.gauche), h(n.droit))
`

]]> Erreur : sans le 1 +, rien ne compte les
arêtes descendues. La fonction renvoie -1
pour tout arbre, vide ou non.

]]> `python
def h(n):
return 1 + max(h(n.gauche), h(n.droit))
`

]]> Erreur : il manque le cas de base. La
récursion descend sur un sous-arbre vide et
n.gauche est alors évalué sur None, ce qui
lève AttributeError.

]]> Arbres binaires — Q13 : Arbre équilibré Qu'est-ce qu'un arbre binaire équilibré ?

]]> Sans équilibrage, un arbre peut dégénérer en
« peigne » (chaque nœud a un seul enfant) de
hauteur n : la recherche devient alors aussi lente
qu'un parcours de liste.

]]> 1.0 0.0 0 true true abc Un arbre où les hauteurs des deux sous-arbres de chaque nœud diffèrent d'au plus 1

]]> Bonne réponse : un arbre équilibré garde une hauteur de
l'ordre de \log_2 n pour n nœuds, ce qui rend la
recherche et l'insertion rapides dans un arbre binaire
de recherche.

]]> Un arbre parfaitement symétrique, aux sous-arbres gauche et droit identiques

]]> Erreur : un arbre équilibré n'est pas
forcément symétrique. La symétrie est une
contrainte plus forte.

]]> Un arbre où la racine se trouve au centre exact de la structure

]]> Erreur : la racine est au sommet, pas au centre.
La notion d'« équilibre » est plus précise.

]]> Un arbre dont tous les nœuds internes possèdent exactement deux enfants, sans exception

]]> Erreur : c'est un arbre plein (ou localement
complet), pas équilibré.

]]> Arbres binaires — Q14 : Code de parcours préfixe Quelle fonction Python affiche les valeurs d'un arbre
binaire en parcours préfixe ?

]]> Le seul changement entre les trois parcours en
profondeur est la position du print par rapport
aux deux appels récursifs. Très instructif à
observer.

]]> 1.0 0.0 0 true true abc `python
def parcours(n):
if n is None: return
print(n.valeur)
parcours(n.gauche)
parcours(n.droit)
`

]]> Bonne réponse : on imprime le nœud avant ses
enfants : c'est la définition même du parcours
préfixe.

]]> `python
def parcours(n):
if n is None: return
parcours(n.gauche)
parcours(n.droit)
print(n.valeur)
`

]]> Erreur : c'est un parcours postfixe (nœud
après les enfants).

]]> `python
def parcours(n):
print(n.valeur)
parcours(n.gauche)
parcours(n.droit)
`

]]> Erreur : il manque le cas de base
if n is None: return. L'appel finit par
descendre sur None et lève
AttributeError avant la fin du parcours.

]]> `python
def parcours(n):
if n is None: return
parcours(n.gauche)
print(n.valeur)
parcours(n.droit)
`

]]> Erreur : c'est le parcours infixe.

]]> Arbres binaires — Q15 : Somme des valeurs d'un arbre Un arbre binaire est construit avec la classe Noeud, un sous-arbre
vide valant None :
`python
class Noeud:
def __init__(self, valeur, gauche, droit):
self.valeur = valeur
self.gauche = gauche
self.droit = droit
def somme(arbre):
if arbre is None:
return 0
return arbre.valeur + somme(arbre.gauche) + somme(arbre.droit)
a = Noeud(5, Noeud(3, None, Noeud(4, None, None)), Noeud(8, None, None))

Que renvoie somme(a)` ?

]]> Une fonction récursive sur un arbre traite d'abord le cas de l'arbre
vide, puis combine la valeur de la racine avec les résultats des deux
sous-arbres. Ici la somme de toutes les valeurs vaut 20.

]]> 1.0 0.0 0 true true abc 20

]]> Bonne réponse : la fonction ajoute la valeur de chaque nœud à la
somme de ses deux sous-arbres, un sous-arbre vide comptant pour 0.
On obtient 5 + 3 + 4 + 8 = 20.

]]> 16

]]> Erreur : 5 + 3 + 8 = 16 s'arrête aux enfants de la racine. Les
appels récursifs descendent jusqu'aux sous-arbres vides et comptent
aussi le nœud 4, fils droit de 3.

]]> Une erreur, car certains sous-arbres valent None

]]> Erreur : le cas de base if arbre is None traite justement les
sous-arbres vides en renvoyant 0, avant toute lecture de
arbre.valeur.

]]> 12

]]> Erreur : 4 + 8 = 12 ne compte que les feuilles. La fonction ajoute
aussi arbre.valeur pour chaque nœud interne, ici 5 et 3.

]]> Arbres binaires — Q16 : Nombre de feuilles Pour un arbre binaire plein (chaque nœud interne a
exactement deux enfants), si f est le nombre de
feuilles et i le nombre de nœuds internes, quelle
relation a-t-on ?

]]> Cette relation s'utilise pour des comptages
d'arbres dans les exercices. Elle vient d'une
symétrie structurelle : chaque nœud interne « remplace
» une feuille par lui-même plus deux nouvelles
feuilles (delta de +1 feuille, +1 interne).

]]> 1.0 0.0 0 true true abc f = 2 · i

]]> Erreur : ne se vérifie pas.

]]> f = i + 1

]]> Bonne réponse : par récurrence sur la taille.
Cas de base : un seul nœud (racine = feuille),
f = 1, i = 0. Pour un arbre plus grand, chaque
nouveau nœud interne ajoute une feuille (en
remplaçant un fils null par un sous-arbre).

]]> f = i

]]> Erreur : la relation est différente. On peut
montrer f = i + 1 par récurrence.

]]> Aucune relation déterministe

]]> Erreur : il existe bien une relation pour les
arbres pleins.

]]> Arbres binaires — Q17 : Implémenter un parcours en largeur Pour implémenter un parcours en largeur d'un arbre
binaire en Python, on utilise généralement :

]]> Code typique, avec une liste Python utilisée
comme file :

`python
def parcours_largeur(racine):
if racine is None:
return
f = [racine]
while len(f) > 0:
n = f.pop(0)
print(n.valeur)
if n.gauche is not None:
f.append(n.gauche)
if n.droit is not None:
f.append(n.droit)
`

]]> 1.0 0.0 0 true true abc Une pile (list avec append et pop)

]]> Erreur : la pile correspond au parcours en
profondeur. Pour la largeur, c'est différent.

]]> Une file (list avec append et pop(0))

]]> Bonne réponse : on enfile la racine, puis tant
que la file n'est pas vide on défile le nœud
courant (pop(0) retire le premier élément) et
on enfile ses deux enfants. La file assure le
traitement niveau par niveau.

]]> Une simple variable mémorisant le nœud courant

]]> Erreur : insuffisant pour stocker plusieurs
nœuds en attente.

]]> Un dictionnaire trié par valeur de nœud

]]> Erreur : pas adapté.

]]> Arbres binaires — Q18 : Borne du nombre de nœuds Quel est le nombre maximum de nœuds d'un arbre
binaire de hauteur h, la hauteur étant comptée
en nombre d'arêtes (un arbre réduit à sa racine a
une hauteur 0) ?

]]> Conséquence : pour avoir n nœuds dans un arbre
équilibré, la hauteur est de l'ordre de \log_2 n.
C'est ce qui rend les arbres de recherche si
efficaces : opérations en O(\log n).

]]> 1.0 0.0 0 true true abc h + 1

]]> Erreur : c'est le nombre minimum (arbre en
peigne).

]]> 2ʰ - 1

]]> Erreur d'une unité dans l'exposant : 2ʰ - 1
est le nombre maximal de nœuds d'un arbre de
hauteur h - 1. Avec la convention « hauteur =
nombre d'arêtes », un arbre parfait de hauteur
h possède h + 1 niveaux, soit 2ʰ⁺¹ - 1
nœuds.

]]> 2ʰ⁺¹ - 1

]]> Bonne réponse : un arbre parfait de hauteur
h a 1 + 2 + 4 + \ldots + 2^h = 2^{h+1} - 1
nœuds. C'est le maximum atteignable.

]]> h²

]]> Erreur : la croissance n'est pas polynomiale
mais exponentielle (en hauteur).

]]> Arbres binaires — Q20 : Arbre miroir Pour calculer le miroir d'un arbre binaire
(échanger gauche et droite à chaque nœud), une approche
récursive est :

]]> C'est un exemple typique d'algorithme récursif
simple sur arbre. La récursion est naturelle car la
structure est elle-même récursive.

]]> 1.0 0.0 0 true true abc Ne rien faire, l'arbre reste inchangé par symétrie

]]> Erreur : ne donne pas le miroir.

]]> Échanger les deux sous-arbres de chaque nœud, récursivement

]]> Bonne réponse : on inverse à tous les niveaux.
En Python :

`python
def miroir(n):
if n is None: return
n.gauche, n.droit = n.droit, n.gauche
miroir(n.gauche)
miroir(n.droit)
`

]]> Échanger uniquement la racine de l'arbre avec sa dernière feuille

]]> Erreur : pas suffisant. Il faut le faire à
chaque nœud, récursivement.

]]> Trier les valeurs des nœuds par ordre décroissant

]]> Erreur : aucun rapport avec le tri.

]]> Arbres binaires — Q21 : Complexité de la recherche Dans un arbre binaire non ordonné de n nœuds, la
recherche d'une valeur a une complexité au pire de :

]]> C'est précisément la motivation des arbres binaires de recherche, qui en ajoutant la
propriété d'ordre, ramènent la recherche à
O(\log n) en moyenne (et O(\log n) garanti si
équilibré).

]]> 1.0 0.0 0 true true abc O(\log n)

]]> Erreur : ce serait dans un arbre ordonné
équilibré (arbre binaire de recherche
équilibré). Sans ordre, on doit
parcourir.

]]> O(n²)

]]> Erreur : excessif. Un simple parcours visite
chaque nœud une fois, donc O(n).

]]> O(√n)

]]> Erreur : aucune raison particulière.

]]> O(n)

]]> Bonne réponse : sans propriété d'ordre, on doit
potentiellement visiter tous les nœuds. Aucun
gain par rapport à une liste.

]]> Arbres binaires — Q24 : Comparer deux arbres récursivement Avec la classe Noeud habituelle (attributs valeur, gauche et
droit, un sous-arbre vide valant None), cette fonction teste si
deux arbres sont identiques :

`python
def egaux(a, b):
if a is None and b is None:
return True
if a is None or b is None:
return False
return (a.valeur == b.valeur and egaux(a.gauche, b.gauche)
and egaux(a.droit, b.droit))

Que se passe-t-il si l'on supprime le second test,
if a is None or b is None`, et la ligne qui le suit ?

]]> Une fonction récursive sur deux arbres doit prévoir tous les cas de
base : les deux arbres vides, un seul vide. Oublier le cas d'un seul
arbre vide conduit à lire un attribut de None, ce qui provoque une
erreur.

]]> 1.0 0.0 0 true true abc Une erreur survient quand un seul des deux sous-arbres comparés est vide

]]> Bonne réponse : si a vaut None et pas b, ou l'inverse, le
premier test échoue et Python lit l'attribut valeur de None, ce
qui lève AttributeError. Si une différence de valeur est repérée
avant, and s'arrête et la fonction renvoie False sans erreur.

]]> La fonction renvoie toujours True, les formes n'étant plus comparées

]]> Erreur : la fonction compare toujours les valeurs et renvoie False
dès que deux valeurs diffèrent. C'est le cas d'un seul sous-arbre
vide qui n'est plus traité.

]]> La fonction reste correcte : ce second test était redondant

]]> Erreur : le premier test ne traite que le cas où les deux arbres sont
vides. Si un seul l'est, l'exécution atteint a.valeur == b.valeur
avec None d'un côté.

]]> Les appels récursifs ne s'arrêtent plus et lèvent RecursionError

]]> Erreur : chaque appel descend d'un niveau dans les deux arbres, qui
sont finis. Les appels s'arrêtent soit sur deux sous-arbres vides,
soit sur une erreur dès qu'un seul l'est.

]]> Arbres binaires — Q25 : Cas d'usage des arbres binaires Lequel des cas suivants utilise typiquement un arbre
binaire ?

]]> Autres usages : analyse syntaxique (arbres de
syntaxe abstraite), systèmes de fichiers (chaque
dossier est un nœud), arbres de jeux (échecs, go),
structures de regroupement hiérarchique. Les arbres
sont omniprésents en informatique.

]]> 1.0 0.0 0 true true abc Échanger le contenu de deux variables d'un programme

]]> L'échange de deux variables
se fait avec une variable
temporaire (ou une affectation
multiple en Python). Cela n'a
aucun lien avec une structure
arborescente.

]]> Compter le nombre total de mots dans un texte

]]> Pour compter des mots,
un simple compteur entier
suffit. Un arbre serait
totalement disproportionné
pour cette tâche.

]]> Représenter une expression arithmétique ou un arbre de décision

]]> Bonne réponse : ces cas exploitent la nature
hiérarchique et/ou récursive de l'arbre. Autre
usage majeur, l'index ordonné (arbre binaire
de recherche), qui maintient un ensemble trié
avec insertion/suppression dynamiques.

]]> Stocker une simple liste de courses du quotidien, sans aucun ordre particulier

]]> Erreur : une liste plate suffit. Pas besoin
d'arbre.

]]> Arbres binaires — Q26 : Calcul récursif de la taille Quelle fonction Python calcule correctement la
taille (nombre total de nœuds) d'un arbre
binaire ?

]]> Cette structure de récursion (cas de base
None → 0, cas récursif 1 + somme des
sous-arbres) est l'archétype de l'algorithme
récursif sur arbre binaire. Elle s'adapte à
d'autres mesures (somme des valeurs, produit,
maximum, etc.) en changeant la combinaison.

]]> 1.0 0.0 0 true true abc `python
def taille(n):
if n is None:
return 0
return taille(n.gauche) + taille(n.droit)
`

]]> Erreur : on oublie de compter le nœud
courant (pas de 1 +). La somme se réduit
de proche en proche à des cas de base
valant 0 : la fonction renvoie 0 pour
tout arbre.

]]> `python
def taille(n):
if n is None:
return 0
return 1 + taille(n.gauche) + taille(n.droit)
`

]]> Bonne réponse : on additionne 1 (pour le nœud
courant) à la somme des tailles des deux
sous-arbres. Le cas de base est l'arbre vide,
de taille 0. Récursion classique sur la
structure d'arbre, en O(n).

]]> `python
def taille(n):
if n is None:
return 1
return taille(n.gauche) + taille(n.droit)
`

]]> Erreur : on compte les feuilles vides
(None) au lieu des nœuds. La taille d'un
arbre à un seul nœud serait 2 au lieu de
1, ce qui est faux.

]]> `python
def taille(n):
if n is None:
return 0
return 1 + max(taille(n.gauche), taille(n.droit))
`

]]> Erreur : on prend ici le maximum au lieu de
la somme. Le résultat correspond à la
hauteur (en nombre de nœuds), pas à la taille.

]]> Arbres binaires — Q27 : Compter les feuilles Quelle fonction Python compte correctement le
nombre de feuilles d'un arbre binaire ?

]]> Cas particulier dans le code : on doit reconnaître
explicitement les feuilles avec
n.gauche is None and n.droit is None. C'est une
différence importante par rapport à la fonction
taille, qui se contente d'additionner sans
distinguer les feuilles.

]]> 1.0 0.0 0 true true abc `python
def feuilles(n):
if n is None:
return 0
return 1 + feuilles(n.gauche) + feuilles(n.droit)
`

]]> Erreur : on ajoute 1 pour chaque nœud,
ce qui compte la taille totale de l'arbre,
pas seulement les feuilles. Il faut distinguer
les feuilles (sans enfant) des nœuds internes
(au moins un enfant).

]]> `python
def feuilles(n):
if n is None:
return 0
if n.gauche is None and n.droit is None:
return 1
return feuilles(n.gauche) + feuilles(n.droit)
`

]]> Bonne réponse : trois cas. (1) Arbre vide :
aucune feuille. (2) Nœud sans enfant : une
feuille. (3) Nœud interne : on additionne les
feuilles des deux sous-arbres. C'est le
patron classique de comptage récursif.

]]> `python
def feuilles(n):
if n is None:
return 0
return feuilles(n.gauche) + feuilles(n.droit)
`

]]> Erreur : il manque le cas où le nœud est une
feuille. Cette fonction renverrait toujours
0 car on ne compte jamais. Récursion
stérile.

]]> `python
def feuilles(n):
if n is None:
return 1
return feuilles(n.gauche) + feuilles(n.droit)
`

]]> Erreur : on compte les positions vides
(None), ce qui donne le double du nombre de
feuilles plus quelque chose pour les nœuds à
un seul enfant. Pas la bonne mesure.

]]> Arbres binaires — Q28 : Profondeur d'un nœud Comment calculer la profondeur d'un nœud
contenant la valeur cible dans un arbre binaire
(ou -1 si la valeur n'est pas présente) ?

]]> Variante intéressante : utiliser un parcours en
largeur avec une file qui contient les couples
(nœud, profondeur). Permet d'éviter la
récursion. Complexité dans les deux cas :
O(n) au pire, où n est le nombre de nœuds.

]]> 1.0 0.0 0 true true abc `python
def profondeur(n, cible):
if n is None:
return 0
if n.valeur == cible:
return 1
return profondeur(n.gauche, cible) + profondeur(n.droit, cible)
`

]]> Erreur : on additionne les résultats des
deux sous-arbres, ce qui n'a pas de sens pour
une profondeur. De plus, on ne propage pas
le compteur de profondeur, donc on ne peut
pas savoir à quelle distance se trouve la
cible.

]]> `python
def profondeur(n, cible):
if n is None:
return -1
if n.valeur == cible:
return 0
g = profondeur(n.gauche, cible)
if g != -1:
return g + 1
return 1 + profondeur(n.droit, cible)
`

]]> Erreur : le cas « absent » n'est pas propagé.
Si la cible n'est ni à gauche ni à droite, la
dernière ligne renvoie 1 + (-1), c'est-à-dire
0, que l'appelant prend pour une profondeur
valide. Une valeur absente de l'arbre reçoit
alors une profondeur fantaisiste au lieu de
-1.

]]> `python
def profondeur(n, cible, p=0):
if n is None:
return -1
if n.valeur == cible:
return p
g = profondeur(n.gauche, cible, p + 1)
if g != -1:
return g
return profondeur(n.droit, cible, p + 1)
`

]]> Bonne réponse : on transmet la profondeur
courante via le paramètre p, qu'on incrémente
à chaque descente récursive. On retourne p
dès que la cible est trouvée. Si la recherche
dans le sous-arbre gauche échoue (-1), on
essaie le droit. Sinon on remonte -1 (cible
absente).

]]> `python
def profondeur(n, cible):
if n.valeur == cible:
return 0
return 1 + profondeur(n.gauche, cible)
`

]]> Erreur : on ne descend que dans le sous-arbre
gauche, et on plante si on atteint un
nœud None sans avoir trouvé la cible.
L'arbre ne se réduit pas à sa branche gauche.

]]> Arbres binaires — Q29 : Les sous-arbres d'un nœud Combien de sous-arbres un nœud d'arbre binaire possède-t-il ?

]]> Un arbre binaire est soit vide, soit un nœud muni d'un sous-arbre
gauche et d'un sous-arbre droit, eux-mêmes binaires.

]]> 1.0 0.0 0 true true abc Un seul, le second n'étant qu'une option

]]> Erreur : les deux positions, gauche et droite, existent
toujours, même vides.

]]> Autant que l'on veut, pourvu qu'ils soient ordonnés

]]> Erreur : c'est la définition d'un arbre général, pas d'un
arbre binaire.

]]> Deux, le gauche et le droit, éventuellement vides

]]> Bonne réponse : la définition récursive donne à chaque nœud
exactement deux sous-arbres ordonnés ; une feuille a deux
sous-arbres vides.

]]> Deux au minimum, un arbre binaire étant toujours complet

]]> Erreur : rien n'impose que les deux sous-arbres soient non
vides.

]]> Arbres binaires — Q30 : Un arbre réduit à une chaîne Dans un arbre binaire de n nœuds, chaque nœud a au plus un
enfant. Que peut-on dire de cet arbre ?

]]> La forme d'un arbre binaire va de la chaîne, hauteur n, à l'arbre
équilibré, hauteur \log n : c'est elle qui fixe le coût des
parcours de la racine à une feuille.

]]> 1.0 0.0 0 true true abc Il est équilibré, chaque nœud ayant au plus un enfant

]]> Erreur : un arbre équilibré répartit les nœuds entre les deux
côtés ; ici tout est d'un seul côté à chaque niveau.

]]> Il est filiforme, de hauteur maximale pour n nœuds

]]> Bonne réponse : les nœuds forment une seule chaîne de la racine
à l'unique feuille ; la hauteur est la plus grande possible,
comme pour une liste chaînée.

]]> Sa hauteur est de l'ordre de \log n, comme toujours

]]> Erreur : c'est la hauteur d'un arbre équilibré ; ici elle est
de l'ordre de n.

]]> Ce n'est pas un arbre binaire, chaque nœud devant avoir deux enfants

]]> Erreur : un sous-arbre vide est permis, l'arbre est bien
binaire.

]]> Arbres binaires — Q31 : Compter les nœuds internes Un arbre binaire compte 7 nœuds, dont 4 feuilles. Combien
a-t-il de nœuds internes ?

]]> Feuilles et nœuds internes forment une partition des nœuds : les
compter l'un donne l'autre.

]]> 1.0 0.0 0 true true abc 6, tous les nœuds sauf la racine

]]> Erreur : la racine est un nœud interne dès qu'elle a un
enfant, et les feuilles n'en sont pas.

]]> 3, les nœuds qui ne sont pas des feuilles

]]> Bonne réponse : un nœud est soit une feuille, soit un nœud
interne ; 7 - 4 = 3.

]]> 4, autant que de feuilles exactement

]]> Erreur : rien n'impose l'égalité ; on retire les feuilles du
total.

]]> 1, la racine étant le seul nœud interne

]]> Erreur : tout nœud ayant au moins un enfant est interne, pas
seulement la racine.

]]> Arbres binaires — Q32 : L'arbre vide L'arbre vide, sans aucun nœud, est-il un arbre binaire ?

]]> Taille nulle, aucune feuille : l'arbre vide est le point de départ
de toutes les mesures récursives.

]]> 1.0 0.0 0 true true abc Oui, mais seulement comme sous-arbre d'une feuille

]]> Erreur : l'arbre vide existe aussi seul, par exemple avant la
première insertion.

]]> Non, il s'agit d'une liste vide et non d'un arbre

]]> Erreur : la structure vide de chaque type existe, liste vide,
pile vide, arbre vide.

]]> Non, un arbre a toujours au moins une racine

]]> Erreur : sans arbre vide, impossible de dire ce qu'est le
sous-arbre gauche d'une feuille.

]]> Oui, c'est le cas de base des définitions récursives

]]> Bonne réponse : tout sous-arbre absent est un arbre vide, et
les fonctions récursives sur les arbres commencent par le
traiter.

]]> Arbres binaires — Q33 : Un arbre représenté par des tuples imbriqués Un arbre est représenté par le tuple (gauche, valeur, droit),
un sous-arbre vide étant None. Que vaut a[2][1] ?
`python
a = ((None, 2, None), 5, (None, 8, None))
`

]]> Avec des tuples, descendre dans l'arbre revient à enchaîner les
indices : 0 pour la gauche, 1 pour la valeur, 2 pour la
droite.

]]> 1.0 0.0 0 true true abc 2, la valeur du fils gauche

]]> Erreur : le fils gauche est a[0].

]]> 8, la valeur du fils droit

]]> Bonne réponse : a[2] est le sous-arbre droit
(None, 8, None), et son élément d'indice 1 est sa
valeur, 8.

]]> 5, la valeur de la racine

]]> Erreur : la valeur de la racine est a[1].

]]> Une erreur, un tuple ne s'indexant pas deux fois

]]> Erreur : a[2] est lui-même un tuple, on peut l'indexer à son
tour.

]]> Arbres binaires — Q34 : Reconnaître une feuille Un nœud est un objet de classe Noeud avec les attributs
valeur, gauche et droit, un sous-arbre vide étant None.
Quelle expression indique que n est une feuille ?

]]> Feuille et arbre vide se distinguent : la feuille est un nœud sans
enfant, l'arbre vide n'est pas un nœud.

]]> 1.0 0.0 0 true true abc n is None, le nœud étant au bout de l'arbre

]]> Erreur : None est l'arbre vide, pas une feuille.

]]> n.gauche is None and n.droit is None

]]> Bonne réponse : une feuille n'a aucun enfant, les deux liens
doivent être absents.

]]> n.gauche is None or n.droit is None

]]> Erreur : un nœud avec un seul enfant vérifie cette condition
sans être une feuille.

]]> n.valeur is None, la feuille ne portant rien

]]> Erreur : la valeur d'une feuille est une donnée ordinaire.

]]> Arbres binaires — Q35 : Lire une fonction récursive sur un arbre Que calcule cette fonction, pour un arbre de nœuds Noeud dont
les sous-arbres vides sont None ?
`python
def compte(a):
if a is None:
return 0
n = compte(a.gauche) + compte(a.droit)
if a.gauche is not None and a.droit is not None:
n = n + 1
return n
`

]]> Lire une fonction récursive sur un arbre, c'est repérer ce qui est
ajouté à chaque nœud et à quelle condition.

]]> 1.0 0.0 0 true true abc La taille de l'arbre, son nombre de nœuds

]]> Erreur : la taille ajouterait 1 pour tout nœud, sans
condition.

]]> Le nombre de nœuds internes, à un ou deux enfants

]]> Erreur : un nœud à un seul enfant est interne mais n'est pas
compté.

]]> Le nombre de nœuds ayant exactement deux enfants

]]> Bonne réponse : chaque nœud ajoute 1 au total de ses
sous-arbres seulement si ses deux enfants existent.

]]> Le nombre de feuilles, nœuds sans enfant

]]> Erreur : une feuille a ses deux liens à None, elle n'ajoute
rien.

]]> Arbres binaires — Q36 : Ordre infixe d'un arbre décrit en mots La racine porte A. Son fils gauche B a deux enfants,
D à gauche et E à droite. Son fils droit C a un
seul enfant, F, à gauche. Quel est le parcours infixe ?

]]> Les trois parcours en profondeur ne diffèrent que par la place du
nœud par rapport à ses deux sous-arbres.

]]> 1.0 0.0 0 true true abc A B D E C F

]]> Erreur : c'est le parcours préfixe, le nœud avant ses
sous-arbres.

]]> D E B F C A

]]> Erreur : c'est le parcours postfixe, le nœud après ses
sous-arbres.

]]> D B E A F C

]]> Bonne réponse : infixe signifie sous-arbre gauche, nœud,
sous-arbre droit, appliqué récursivement : D B E,
puis A, puis F C.

]]> A B C D E F

]]> Erreur : c'est le parcours en largeur, niveau par niveau.

]]> Arbres binaires — Q37 : Retrouver un arbre à partir de deux parcours Un arbre binaire de trois nœuds a pour parcours préfixe
A B C et pour parcours infixe B A C. Quel est
cet arbre ?

]]> Le préfixe donne la racine, l'infixe sépare ce qui est à gauche de
ce qui est à droite : les deux parcours ensemble déterminent
l'arbre.

]]> 1.0 0.0 0 true true abc Racine A, fils gauche B, fils droit C

]]> Bonne réponse : le préfixe commence par la racine, A ; dans
l'infixe, ce qui précède A est à gauche, B, et ce qui
suit est à droite, C.

]]> Racine B, fils gauche A, fils droit C

]]> Erreur : le premier nœud du parcours préfixe est la racine,
A.

]]> Racine A, fils gauche C, fils droit B

]]> Erreur : le parcours infixe placerait alors C avant A.

]]> Racine C, fils gauche B, fils droit A

]]> Erreur : C est le dernier du préfixe, il ne peut pas être
la racine.

]]> Arbres binaires — Q38 : Les feuilles d'un arbre aux niveaux pleins Un arbre binaire a 3 niveaux, tous pleins. Combien de feuilles
compte-t-il ?

]]> Dans un arbre aux niveaux pleins, chaque niveau double le
précédent : la moitié des nœuds, à un près, sont des feuilles.

]]> 1.0 0.0 0 true true abc 3, une seule par niveau

]]> Erreur : les feuilles sont toutes au dernier niveau, pas une
par niveau.

]]> 8, le double du dernier niveau

]]> Erreur : 2³ serait le niveau suivant, qui n'existe pas.

]]> 4, le dernier niveau entier

]]> Bonne réponse : le niveau k contient 2ᵏ⁻¹ nœuds ; les
feuilles sont les 2² = 4 nœuds du dernier niveau.

]]> 7, tous les nœuds de l'arbre

]]> Erreur : 7 est le nombre total de nœuds, dont seuls ceux du
dernier niveau sont des feuilles.

]]> Arbres binaires — Q39 : Feuilles et nœuds à deux enfants Dans un arbre binaire, chaque nœud interne a exactement deux
enfants. L'arbre compte 4 nœuds internes. Combien a-t-il de
feuilles ?

]]> Dans un arbre binaire où tout nœud interne a deux enfants, le
nombre de feuilles dépasse de un le nombre de nœuds internes : un
résultat qui se prouve par récurrence sur la taille.

]]> 1.0 0.0 0 true true abc 8, deux feuilles par nœud interne

]]> Erreur : les enfants d'un nœud interne sont souvent eux-mêmes
internes, pas des feuilles.

]]> 3, une de moins que de nœuds internes

]]> Erreur : le sens de la différence est inversé.

]]> 4, autant que de nœuds internes

]]> Erreur : il y en a toujours une de plus.

]]> 5, une de plus que de nœuds internes

]]> Bonne réponse : l'arbre réduit à une feuille vérifie la
relation ; remplacer une feuille par un nœud à deux enfants
ajoute un interne et une feuille nette. D'où 4 + 1 = 5.

]]>