\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Arbres binaires}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en D
\begin{frame}[fragile]{Question 1 \textemdash{} Définition d'un arbre binaire}
    Qu'est-ce qu'un \textbf{arbre binaire} ?\medskip
    \begin{itemize}
        \item[A.] Un arbre dont les nœuds contiennent uniquement deux valeurs
        \item[B.] Une structure linéaire avec deux pointeurs par élément
        \item[C.] Un arbre généalogique
        \item[\alert<2>{D.}] \alert<2>{Une structure hiérarchique où chaque nœud a au plus deux enfants (gauche et droit)}
    \end{itemize}
\end{frame}

% Q2 - Réponse en B
\begin{frame}[fragile]{Question 2 \textemdash{} Racine}
    Combien de \textbf{racines} un arbre binaire possède-t-il ?\medskip
    \begin{itemize}
        \item[A.] Aucune
        \item[\alert<2>{B.}] \alert<2>{Exactement une}
        \item[C.] Cela dépend de la profondeur
        \item[D.] Plusieurs, autant que de feuilles
    \end{itemize}
\end{frame}

% Q3 - Réponse en D
\begin{frame}[fragile]{Question 3 \textemdash{} Feuille}
    Qu'est-ce qu'une \textbf{feuille} dans un arbre binaire ?\medskip
    \begin{itemize}
        \item[A.] La racine de l'arbre
        \item[B.] Un nœud à mi-hauteur de l'arbre
        \item[C.] Un nœud qui a exactement deux enfants
        \item[\alert<2>{D.}] \alert<2>{Un nœud qui n'a aucun enfant}
    \end{itemize}
\end{frame}

% Q4 - Réponse en C
\begin{frame}[fragile]{Question 4 \textemdash{} Hauteur d'un arbre}
    Qu'appelle-t-on \textbf{hauteur} d'un arbre binaire ?\medskip
    \begin{itemize}
        \item[A.] La distance entre deux feuilles
        \item[B.] Le nombre de feuilles
        \item[\alert<2>{C.}] \alert<2>{La longueur du plus long chemin de la racine à une feuille (compté en nombre d'arêtes)}
        \item[D.] Le nombre total de nœuds
    \end{itemize}
\end{frame}

% Q5 - Réponse en B
\begin{frame}[fragile]{Question 5 \textemdash{} Profondeur d'un nœud}
    La \textbf{profondeur} d'un nœud dans un arbre est :\medskip
    \begin{itemize}
        \item[A.] Le nombre de feuilles sous ce nœud
        \item[\alert<2>{B.}] \alert<2>{La longueur du chemin de la racine jusqu'à ce nœud}
        \item[C.] Le nombre de ses descendants
        \item[D.] La distance jusqu'à sa feuille la plus proche
    \end{itemize}
\end{frame}

% Q6 - Réponse en A
\begin{frame}[fragile]{Question 6 \textemdash{} Parcours préfixe}
    Dans un parcours \textbf{préfixe} (ou \textit{pre-order}), dans
quel ordre visite-t-on les nœuds ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Nœud, sous-arbre gauche, sous-arbre droit}
        \item[B.] Sous-arbre droit, nœud, sous-arbre gauche
        \item[C.] Sous-arbre gauche, nœud, sous-arbre droit
        \item[D.] Sous-arbre gauche, sous-arbre droit, nœud
    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile]{Question 7 \textemdash{} Parcours infixe}
    Dans quel ordre s'effectue un parcours \textbf{infixe} d'un
arbre binaire ?\medskip
    \begin{itemize}
        \item[A.] Nœud, sous-arbre gauche, sous-arbre droit
        \item[B.] Sous-arbre gauche, sous-arbre droit, nœud
        \item[\alert<2>{C.}] \alert<2>{Sous-arbre gauche, nœud, sous-arbre droit}
        \item[D.] Toutes les feuilles d'abord, puis tous les nœuds internes
    \end{itemize}
\end{frame}

% Q8 - Réponse en A
\begin{frame}[fragile]{Question 8 \textemdash{} Parcours postfixe}
    Le parcours \textbf{postfixe} visite :\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{D'abord le sous-arbre gauche, puis le sous-arbre droit, et enfin le nœud}
        \item[B.] Uniquement les feuilles
        \item[C.] Les nœuds dans un ordre aléatoire
        \item[D.] D'abord le nœud, puis les enfants
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Parcours en largeur}
    Le parcours en \textbf{largeur} d'un arbre :\medskip
    \begin{itemize}
        \item[A.] Visite la branche gauche en entier avant la droite
        \item[\alert<2>{B.}] \alert<2>{Visite tous les nœuds à profondeur $0$, puis $1$, puis $2$, etc.}
        \item[C.] Visite uniquement les nœuds internes
        \item[D.] Évalue une expression arithmétique
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile]{Question 10 \textemdash{} Taille d'un arbre}
    La \textbf{taille} d'un arbre binaire est :\medskip
    \begin{itemize}
        \item[A.] Le nombre d'arêtes
        \item[B.] La hauteur du plus long chemin
        \item[\alert<2>{C.}] \alert<2>{Le nombre total de nœuds}
        \item[D.] Le nombre de feuilles
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile]{Question 11 \textemdash{} Implémentation Python}
    Une implémentation simple d'un nœud d'arbre binaire en
Python utilise :\medskip
    \begin{itemize}
        \item[A.] Une chaîne de caractères
        \item[B.] Un dictionnaire avec une clé entière
        \item[C.] Une liste de longueur fixe \texttt{[valeur, gauche, droite]}
        \item[\alert<2>{D.}] \alert<2>{Une classe avec trois attributs (\texttt{valeur}, \texttt{gauche}, \texttt{droit}), où \texttt{gauche} et \texttt{droit} sont soit \texttt{None} soit un autre nœud}
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} 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) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def h(n):
    return n.gauche + n.droit
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def h(n):
    if n is None: return 0
    return 1 + h(n.gauche) + h(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def h(n):
    return len(n)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def h(n):
    if n is None: return -1
    return 1 + max(h(n.gauche), h(n.droit))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} 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) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def h(n):
    return n.gauche + n.droit
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def h(n):
    if n is None: return 0
    return 1 + h(n.gauche) + h(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def h(n):
    return len(n)
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def h(n):
    if n is None: return -1
    return 1 + max(h(n.gauche), h(n.droit))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q13 - Réponse en C
\begin{frame}[fragile]{Question 13 \textemdash{} Arbre équilibré}
    Qu'est-ce qu'un arbre binaire \textbf{équilibré} ?\medskip
    \begin{itemize}
        \item[A.] Un arbre où tous les nœuds ont exactement deux enfants
        \item[B.] Un arbre symétrique (gauche et droite identiques)
        \item[\alert<2>{C.}] \alert<2>{Un arbre où, pour chaque nœud, les hauteurs des sous-arbres gauche et droit diffèrent au plus de $1$}
        \item[D.] Un arbre où la racine est au centre
    \end{itemize}
\end{frame}

% Q14 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Code de parcours préfixe}
    Quelle fonction Python affiche les valeurs d'un arbre
binaire en parcours \textbf{préfixe} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    print(n.valeur)
    parcours(n.gauche)
    parcours(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def parcours(n):
    print(n.valeur)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    parcours(n.gauche)
    parcours(n.droit)
    print(n.valeur)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    parcours(n.gauche)
    print(n.valeur)
    parcours(n.droit)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q14 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Code de parcours préfixe}
    Quelle fonction Python affiche les valeurs d'un arbre
binaire en parcours \textbf{préfixe} ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    print(n.valeur)
    parcours(n.gauche)
    parcours(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def parcours(n):
    print(n.valeur)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    parcours(n.gauche)
    parcours(n.droit)
    print(n.valeur)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def parcours(n):
    if n is None: return
    parcours(n.gauche)
    print(n.valeur)
    parcours(n.droit)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile]{Question 15 \textemdash{} Arbre complet}
    Un arbre binaire est dit \textbf{complet} quand :\medskip
    \begin{itemize}
        \item[A.] Il contient au moins une feuille
        \item[B.] Toutes les feuilles sont à la même profondeur
        \item[\alert<2>{C.}] \alert<2>{Tous les niveaux sont entièrement remplis, sauf éventuellement le dernier qui est rempli de gauche à droite}
        \item[D.] La racine a un enfant gauche et un enfant droit
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} Nombre de feuilles}
    Pour un arbre binaire \textbf{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 ?\medskip
    \begin{itemize}
        \item[A.] Aucune relation déterministe
        \item[\alert<2>{B.}] \alert<2>{$f = i + 1$}
        \item[C.] $f = i$
        \item[D.] $f = 2 \cdot i$
    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile]{Question 17 \textemdash{} Implémenter un parcours en largeur}
    Pour implémenter un parcours en largeur d'un arbre
binaire en Python, on utilise généralement :\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une file (\texttt{collections.deque} avec \texttt{append} et \texttt{popleft})}
        \item[B.] Une variable simple
        \item[C.] Une pile (\texttt{list} avec \texttt{append} et \texttt{pop})
        \item[D.] Un dictionnaire trié
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile]{Question 18 \textemdash{} Borne du nombre de nœuds}
    Quel est le nombre \textbf{maximum} de nœuds d'un arbre
binaire de hauteur $h$ ?\medskip
    \begin{itemize}
        \item[A.] $h + 1$
        \item[B.] $h^2$
        \item[C.] $h$
        \item[\alert<2>{D.}] \alert<2>{$2^{h+1} - 1$}
    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile]{Question 19 \textemdash{} É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 :\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Postfixe}
        \item[B.] Infixe
        \item[C.] Aléatoire
        \item[D.] Préfixe
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile]{Question 20 \textemdash{} Arbre miroir}
    Pour calculer le \textbf{miroir} d'un arbre binaire
(échanger gauche et droite à chaque nœud), une approche
récursive est :\medskip
    \begin{itemize}
        \item[A.] Échanger uniquement la racine avec la dernière feuille
        \item[\alert<2>{B.}] \alert<2>{Pour chaque nœud, échanger ses deux sous-arbres puis appliquer récursivement le miroir aux sous-arbres}
        \item[C.] Ne rien faire
        \item[D.] Trier les éléments par ordre décroissant
    \end{itemize}
\end{frame}

% Q21 - Réponse en B
\begin{frame}[fragile]{Question 21 \textemdash{} Complexité de la recherche}
    Dans un arbre binaire \textbf{non ordonné} de $n$ nœuds, la
recherche d'une valeur a une complexité au pire de :\medskip
    \begin{itemize}
        \item[A.] $O(\log n)$
        \item[\alert<2>{B.}] \alert<2>{$O(n)$}
        \item[C.] $O(n^2)$
        \item[D.] $O(\sqrt{n})$
    \end{itemize}
\end{frame}

% Q22 - Réponse en C
\begin{frame}[fragile]{Question 22 \textemdash{} Reconstruction d'arbre}
    Connaissant à la fois le parcours \textbf{préfixe} et le
parcours \textbf{infixe} d'un arbre binaire (sans valeurs
dupliquées), peut-on reconstruire l'arbre de manière
unique ?\medskip
    \begin{itemize}
        \item[A.] Seulement si l'arbre est équilibré
        \item[B.] Non, il y a toujours plusieurs arbres possibles
        \item[\alert<2>{C.}] \alert<2>{Oui, c'est un théorème classique}
        \item[D.] Cela dépend de la profondeur
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile]{Question 23 \textemdash{} Diamètre d'un arbre}
    Le \textbf{diamètre} d'un arbre binaire est :\medskip
    \begin{itemize}
        \item[A.] La hauteur de l'arbre
        \item[B.] Le nombre total de nœuds
        \item[C.] Le nombre total de feuilles
        \item[\alert<2>{D.}] \alert<2>{La longueur du plus long chemin entre deux nœuds (pas forcément passant par la racine)}
    \end{itemize}
\end{frame}

% Q24 - Réponse en A
\begin{frame}[fragile]{Question 24 \textemdash{} Représentation par tableau}
    Quand peut-on représenter efficacement un arbre binaire
dans un \textbf{tableau} (sans pointeurs) ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Quand l'arbre est complet (tous les niveaux remplis sauf éventuellement le dernier rempli de gauche à droite)}
        \item[B.] Quand l'arbre a moins de $10$ nœuds
        \item[C.] Toujours, c'est universel
        \item[D.] Jamais, c'est inefficace
    \end{itemize}
\end{frame}

% Q25 - Réponse en D
\begin{frame}[fragile]{Question 25 \textemdash{} Cas d'usage des arbres binaires}
    Lequel des cas suivants utilise typiquement un arbre
binaire ?\medskip
    \begin{itemize}
        \item[A.] Stocker une liste de courses ordinaire
        \item[B.] Échanger deux variables
        \item[C.] Compter le nombre de mots dans un texte
        \item[\alert<2>{D.}] \alert<2>{Représenter un arbre de décision, une expression arithmétique, ou un index ordonné dynamique (arbre binaire de recherche)}
    \end{itemize}
\end{frame}

% Q26 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Calcul récursif de la taille}
    Quelle fonction Python calcule correctement la
\textbf{taille} (nombre total de nœuds) d'un arbre
binaire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 0
    return 1 + max(taille(n.gauche), taille(n.droit))
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 0
    return 1 + taille(n.gauche) + taille(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 1
    return taille(n.gauche) + taille(n.droit)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def taille(n):
    return 1
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q26 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Calcul récursif de la taille}
    Quelle fonction Python calcule correctement la
\textbf{taille} (nombre total de nœuds) d'un arbre
binaire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 0
    return 1 + max(taille(n.gauche), taille(n.droit))
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 0
    return 1 + taille(n.gauche) + taille(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def taille(n):
    if n is None:
        return 1
    return taille(n.gauche) + taille(n.droit)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def taille(n):
    return 1
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Compter les feuilles}
    Quelle fonction Python compte correctement le
nombre de \textbf{feuilles} d'un arbre binaire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 1
    return feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 0
    return feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 0
    return 1 + feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
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)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Compter les feuilles}
    Quelle fonction Python compte correctement le
nombre de \textbf{feuilles} d'un arbre binaire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 1
    return feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 0
    return feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def feuilles(n):
    if n is None:
        return 0
    return 1 + feuilles(n.gauche) + feuilles(n.droit)
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
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)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Profondeur d'un nœud}
    Comment calculer la \textbf{profondeur} d'un nœud
contenant la valeur \texttt{cible} dans un arbre binaire
(ou \texttt{-1} si la valeur n'est pas présente) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def profondeur(n, cible):
    return n.valeur - cible
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def profondeur(n, cible):
    if n.valeur == cible:
        return 0
    return 1 + profondeur(n.gauche, cible)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
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)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
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)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Profondeur d'un nœud}
    Comment calculer la \textbf{profondeur} d'un nœud
contenant la valeur \texttt{cible} dans un arbre binaire
(ou \texttt{-1} si la valeur n'est pas présente) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def profondeur(n, cible):
    return n.valeur - cible
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def profondeur(n, cible):
    if n.valeur == cible:
        return 0
    return 1 + profondeur(n.gauche, cible)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
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)
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
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)
\end{lstlisting}

    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
