\begin{questions}
\item Au début, \texttt{passage=0}, \texttt{permut=Vrai} et \texttt{n=3}.
\begin{itemize}
\item Entrée dans la boucle itérative : \texttt{i=0}. \texttt{a[0] > a[1]} ($3>2$) donc \texttt{temp=2}, \texttt{a[1]=3}, \texttt{a[0]=2} et \texttt{permut=Vrai}.
\item \texttt{i=1} : \texttt{a[1]>a[2]} ($3>1$) donc \texttt{temp=1}, \texttt{a[2]=3}, \texttt{a[1]=1} et\linebreak \texttt{permut=Vrai}.
\item Fin du Pour : \texttt{passage=1}. À ce stade, \texttt{a=[2,1,3]}.
\item \texttt{permut=Vrai} donc on entre dans la boucle \og Tant que \fg.
\item \texttt{permut=Faux}, \texttt{n-2-passage=3-2-1=0} et \texttt{i=0} : \texttt{a[0]>a[1]} ($2>1$) donc \texttt{temp=1}, \texttt{a[1]=2}, \texttt{a[0]=1} et \texttt{permut=Vrai}.
\item Fin de la boucle itérative Pour. À ce stade, \texttt{a=[1,2,3]}, \texttt{permut=Vrai} et \texttt{passage=2}.
\item Entrée dans la boucle \og Tant que \fg{} car \texttt{permut=Vrai} : \texttt{permut=Faux} et comme \texttt{n-2-passage=-1}, on n'entre pas dans la boucle \og Pour \fg.
\item Fin de la boucle \og Tant que \fg{}  car \texttt{permut=Faux}.
\end{itemize}
Ainsi, le tableau \texttt{[3,2,1]} devient \texttt{[1,2,3]}.

\Par

Une autre façon de représenter les résultats successifs est le tableau\linebreak suivant :

\begin{center}
\begin{tabular}{|>{\ttfamily}C|*5{Zc|}}
\hline
a & [3,2,1] & [2,3,1] & [2,1,3] & [1,2,3] & [1,2,3]\\\hline
permut & vrai & vrai & vrai & vrai & faux\\\hline
n-2-passage & 1 & 1 & 0 & -1 & --\\\hline
i & 0 & 1 & 0 & -- & --\\\hline
a[i]>a[i+1]&  vrai & vrai & vrai & --& --\\\hline
temp & 2 & 1 & 1 & -- & --\\\hline
a[i+1] & 3 & 3 & 2 & -- & --\\\hline
a[i] & 2 & 1 & 1 & -- & --\\\hline
passage & 0 & 1 & 2 & 3 & --\\\hline
\end{tabular}
\end{center}

\Par

\item La boucle itérative nous informe que l'on parcourt le tableau \texttt{a}. La boucle conditionnelle \og Si a[i] > a[i+1] \fg{} nous dit que l'on intervertit deux valeurs consécutives si la première est supérieure à la seconde.

Ainsi, on parcourt le tableau et on intervertit deux valeurs consécutives s'il le faut pour les mettre dans l'ordre croissant. Si tel est le cas, le booléen \texttt{permut} vaut \textit{Vrai}.

La boucle \og Tant que \fg{} nous informe que ce processus est répété jusqu'à ce qu'il n'y ait plus d'échange, donc jusqu'à ce que les valeurs du tableau soit toutes dans l'ordre croissant.

L'algorithme trie alors le tableau initial.

\item Le pire des cas est un tableau où toutes les valeurs sont dans l'ordre décroissant. Dans ce cas, la boucle \og Pour \fg{} effectue dans un premier temps $n-1$ itérations, puis $n-2$ itérations, etc. jusqu'à 1 itération, soit au total :
\[
\sum_{k=1}^{n-1}(n-k)=n^2-(1+2+3+\cdots+1)=n^2-\dfrac{n(n+1)}{2}=\dfrac{n^2-n}{2}
\]
itérations.

Le coût de l'algorithme est donc de l'ordre de $n^2$.

Il est donc quadratique.
\end{questions}
\newpage
