$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 Un arbre dont les nœuds contiennent uniquement deux valeurs

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

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

]]> Un arbre généalogique

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

]]> Une structure hiérarchique où chaque nœud a au plus deux enfants (gauche et droit)

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

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

]]> Erreur : un arbre non vide a toujours exactement
une racine. Seul l'arbre vide n'a pas de 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.

]]> Cela dépend de la profondeur

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

]]> Plusieurs, autant que de feuilles

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

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

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

]]> 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 entre deux feuilles

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

]]> Le nombre de feuilles

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

]]> La longueur du plus long chemin de la racine à une feuille (compté en nombre d'arêtes)

]]> Bonne réponse : convention courante. 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

]]> Erreur : c'est la taille, pas la 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 de feuilles sous ce nœud

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

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

]]> Le nombre de ses descendants

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

]]> La distance jusqu'à sa feuille la plus proche

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

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

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

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

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

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

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

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

]]> 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 Nœud, sous-arbre gauche, sous-arbre droit

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

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

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

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

]]> Toutes les feuilles d'abord, puis tous les nœuds internes

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

]]> 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 sous-arbre gauche, puis le sous-arbre droit, et enfin 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

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

]]> Les nœuds dans un ordre aléatoire

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

]]> D'abord le nœud, puis les enfants

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

]]> 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 la branche gauche en entier avant la droite

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

]]> 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 uniquement les nœuds internes

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

]]> Évalue une expression arithmétique

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

]]> 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^{h+1} - 1$ nœuds. C'est le nombre maximum,
atteint quand l'arbre est parfaitement équilibré.

]]> 1.0 0.0 0 true true abc 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.

]]> La hauteur du plus long chemin

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

]]> 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})$.

]]> Le nombre de feuilles

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

]]> Arbres binaires — Q11 : Implémentation Python Une implémentation simple d'un nœud d'arbre binaire en
Python utilise :

]]> 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 chaîne de caractères

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

]]> Un dictionnaire avec une clé entière

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

]]> Une liste de longueur fixe [valeur, gauche, droite]

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

]]> Une classe avec trois attributs (valeur, gauche, droit), où gauche et droit sont soit None soit un autre nœud

]]> Bonne réponse : c'est l'approche orientée objet
standard. Exemple :

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

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

def h(n):
    return n.gauche + n.droit

]]> Erreur : on additionne des nœuds, ça n'a pas de
sens.

]]>

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.

]]>

def h(n):
    return len(n)

]]> Erreur : len ne s'applique pas à un objet
arbitraire.

]]>

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

]]> 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) avec
hauteur $n$ et opérations en $O(n)$. Les arbres
AVL et rouge-noir sont des structures
auto-équilibrantes.

]]> 1.0 0.0 0 true true abc Un arbre où tous les nœuds ont exactement deux enfants

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

]]> Un arbre symétrique (gauche et droite identiques)

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

]]> Un arbre où, pour chaque nœud, les hauteurs des sous-arbres gauche et droit diffèrent au plus de $1$

]]> Bonne réponse : c'est la définition de
l'équilibre AVL. Un arbre équilibré garantit une
hauteur $O(\log n)$, ce qui rend les opérations
de recherche, insertion, suppression rapides.

]]> Un arbre où la racine est au centre

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

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

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.

]]>

def parcours(n):
    print(n.valeur)

]]> Erreur : ne descend pas dans les sous-arbres.

]]>

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

]]>

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 : Arbre complet Un arbre binaire est dit complet quand :

]]> Cette structure est utilisée dans les tas binaires
(priority queues), où l'arbre complet est représenté
en tableau pour économiser la mémoire et garantir
une complexité $O(\log n)$ des opérations.

]]> 1.0 0.0 0 true true abc Il contient au moins une feuille

]]> Erreur : trivialement vrai pour tout arbre non
vide. Pas une définition utile.

]]> Toutes les feuilles sont à la même profondeur

]]> Erreur : c'est plutôt un arbre parfait, plus
strict.

]]> Tous les niveaux sont entièrement remplis, sauf éventuellement le dernier qui est rempli de gauche à droite

]]> Bonne réponse : c'est la propriété qui permet
d'implémenter un arbre complet par un tableau
(sans pointeurs), avec la convention que pour le
nœud à l'index $i$, ses enfants sont aux indices
$2i+1$ et $2i+2$.

]]> La racine a un enfant gauche et un enfant droit

]]> Erreur : trop faible. Un arbre complet exige bien
plus.

]]> 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 Aucune relation déterministe

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

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

]]> $f = 2 \cdot i$

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

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

from collections import deque
def bfs(racine):
    if racine is None: return
    f = deque([racine])
    while f:
        n = f.popleft()
        print(n.valeur)
        if n.gauche: f.append(n.gauche)
        if n.droit:  f.append(n.droit)

]]> 1.0 0.0 0 true true abc Une file (collections.deque avec append et popleft)

]]> Bonne réponse : on enfile la racine, puis tant
que la file n'est pas vide on défile le nœud
courant et on enfile ses deux enfants. Le file
assure le traitement niveau par niveau.

]]> Une variable simple

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

]]> Une pile (list avec append et pop)

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

]]> Un dictionnaire trié

]]> 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$ ?

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

]]> $h^2$

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

]]> $h$

]]> Erreur : un arbre dégénéré (peigne) a déjà $h+1$
nœuds. Et un arbre équilibré en a beaucoup plus.

]]> $2^{h+1} - 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.

]]> Arbres binaires — Q19 : Évaluation d'expression arithmétique Pour évaluer une expression arithmétique représentée
par un arbre (les feuilles sont des nombres, les nœuds
internes des opérateurs), on utilise un parcours :

]]> L'arbre d'expression de (2 + 3) 4 a à la
racine, avec sous-arbre gauche + (de fils $2$ et
$3$) et sous-arbre droit feuille $4$. Évaluation
postfixe : $2 + 3 = 5$, puis $5 \times 4 = 20$.

]]> 1.0 0.0 0 true true abc Postfixe

]]> Bonne réponse : on évalue d'abord les sous-arbres
gauche et droit (récursivement), puis on
applique l'opérateur du nœud courant. C'est
exactement la sémantique de l'arithmétique
mathématique.

]]> Infixe

]]> Erreur : l'infixe affiche dans l'ordre lisible
humain, mais on a besoin d'évaluer les
sous-arbres avant le nœud, ce qui est postfixe.

]]> Aléatoire

]]> Erreur : l'évaluation doit suivre un ordre
précis.

]]> Préfixe

]]> Erreur : un parcours préfixe affiche d'abord
l'opérateur, donc on n'a pas encore les valeurs
au moment du calcul.

]]> 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 Échanger uniquement la racine avec la dernière feuille

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

]]> Pour chaque nœud, échanger ses deux sous-arbres puis appliquer récursivement le miroir aux sous-arbres

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

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

]]> Ne rien faire

]]> Erreur : ne donne pas le miroir.

]]> Trier les éléments 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)$

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

]]> $O(n^2)$

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

]]> $O(\sqrt{n})$

]]> Erreur : aucune raison particulière.

]]> Arbres binaires — Q22 : Reconstruction d'arbre Connaissant à la fois le parcours préfixe et le
parcours infixe d'un arbre binaire (sans valeurs
dupliquées), peut-on reconstruire l'arbre de manière
unique ?

]]> Question classique d'examens. Le couple
(préfixe, infixe) ou (postfixe, infixe) suffit. Le
couple (préfixe, postfixe) ne suffit pas en général.

]]> 1.0 0.0 0 true true abc Seulement si l'arbre est équilibré

]]> Erreur : aucune contrainte d'équilibrage
requise.

]]> Non, il y a toujours plusieurs arbres possibles

]]> Erreur : ces deux parcours combinés permettent
en réalité une reconstruction unique.

]]> Oui, c'est un théorème classique

]]> Bonne réponse : le préfixe donne la racine en
premier, l'infixe sépare les éléments à gauche
et à droite de la racine. On reconstruit
récursivement. Le préfixe seul ne suffit pas
(deux arbres peuvent avoir le même préfixe).

]]> Cela dépend de la profondeur

]]> Erreur : non, le théorème vaut pour toute
profondeur.

]]> Arbres binaires — Q23 : Diamètre d'un arbre Le diamètre d'un arbre binaire est :

]]> Calcul classique : pour chaque nœud, calculer la
profondeur de ses sous-arbres gauche et droit. Le
diamètre passant par ce nœud est leur somme + $2$
(les deux arêtes vers les sous-arbres). Le diamètre
global est le maximum sur tous les nœuds.

]]> 1.0 0.0 0 true true abc La hauteur de l'arbre

]]> Erreur : la hauteur part de la racine. Le
diamètre peut ne pas la passer.

]]> Le nombre total de nœuds

]]> Erreur : c'est la taille.

]]> Le nombre total de feuilles

]]> Le nombre de feuilles
n'est pas une distance
dans l'arbre. Le diamètre
mesure la longueur d'un
chemin, pas un comptage
de nœuds.

]]> La longueur du plus long chemin entre deux nœuds (pas forcément passant par la racine)

]]> Bonne réponse : c'est une notion plus subtile
que la hauteur. Le diamètre peut traverser
l'arbre via la racine ou rester dans un
sous-arbre. Calcul en $O(n)$ par parcours
récursif intelligent.

]]> Arbres binaires — Q24 : Représentation par tableau Quand peut-on représenter efficacement un arbre binaire
dans un tableau (sans pointeurs) ?

]]> Cette représentation est utilisée dans les tas
binaires (heaps), qui sont des arbres complets
ordonnés par priorité. Avantages : pas de
pointeurs, données contiguës, cache CPU efficace.

]]> 1.0 0.0 0 true true abc Quand l'arbre est complet (tous les niveaux remplis sauf éventuellement le dernier rempli de gauche à droite)

]]> Bonne réponse : la représentation par tableau est
compacte uniquement si l'arbre est complet. À la
racine on stocke en index $0$ (ou $1$), pour le
nœud à l'index $i$ les enfants sont en $2i+1$ et
$2i+2$, et le parent en $(i-1)/2$.

]]> Quand l'arbre a moins de $10$ nœuds

]]> Erreur : pas de seuil de taille, mais une
condition structurelle.

]]> Toujours, c'est universel

]]> Erreur : pour un arbre quelconque (avec des
« trous »), on gaspillerait beaucoup de mémoire.

]]> Jamais, c'est inefficace

]]> Erreur : c'est au contraire très efficace pour
les arbres complets (tas binaires).

]]> 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 Stocker une liste de courses ordinaire

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

]]> Échanger deux variables

]]> 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 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 un arbre de décision, une expression arithmétique, ou un index ordonné dynamique (arbre binaire de recherche)

]]> Bonne réponse : ces cas exploitent la nature
hiérarchique et/ou récursive de l'arbre.
Particulièrement utile quand on veut maintenir
un ensemble trié avec insertion/suppression
dynamiques.

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

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.

]]>

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

]]>

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.

]]>

def taille(n):
    return 1

]]> Erreur : on renvoie toujours $1$, sans
parcourir l'arbre. Pour tout arbre, la
fonction renverrait $1$, ce qui n'est pas la
taille (sauf cas trivial d'un seul nœud).

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

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.

]]>

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.

]]>

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

]]>

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.

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

def profondeur(n, cible):
    return n.valeur - cible

]]> Erreur grossière : on calcule une différence
de valeurs, ce qui n'a aucun rapport avec une
profondeur dans un arbre.

]]>

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.

]]>

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.

]]>

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

]]>