% Section Partie 2 - SAE 2.02

\documentclass[class=article, crop=false]{standalone}


\begin{document}

\section{Partie 2}

  \subsection{Question 1}
    \par\quad 

  \subsection{Question 2 et 4}
    \par\quad Interressons-nous maintenant au calcul de la complexité de chaque algorithmes. Un calcul de omplexité s'effectue en comptabilisant le nombre d'action que le processeur doit effectuer. Cependant, pour effectuer un tel calcul, il faudrait comptabiliser la totalité des actions effectuées par l'ensemble des bibliothèques utilisées dans les algorithmes. Nous n'avons pas besoin d'aller aussi loin, notamment car dans ce cas, ce calcul changerait en fonction d'un language à un autre, d'un compilateur à un autre, ou encore d'un interpréteur à un autre. Nous allons donc nous intéresser uniquement au nombre de lignes executés par les programmes en fonction de parmamêtres donnés.


    \subsubsection{Complexité de l'algorithme n°1}
    \par\quad Pour ce qui est du premier algorithme proposé, nous pouvons déjà comptabiliser les 4 actions effectuées par la fonction annexe "echanger". Ajoutons-y les 4 création de variables en début d'algorithme. On remarque que les instructions d'après sont bouclées en fonction de paramètres variables. On en déduit donc que nous avons déjà 4 instructions fixes et 4 autres que l'on multiplira par le nombre de fois que la fonction "echanger" est appelée.

    \par\quad La première boucle (while), qui est la boucle principale tourne tant que la variable échange est à 1. cette variable comptabilise le nombre d'échanges de valeurs qui est effectué pour ordonner le tableau. Notre equation de complexité se construit donc avec la forme : $4 + N * (4 + P)$, où $N$ est le nombre de fois que la boucle tourne et $P$ le nombre d'actions effectuées dans cette boucle.

    \par\quad Dans cette boucle while, on trouve deux boucles "for" pour trier les valeurs du début et de la fin. En analysant l'algorithme caractérisant ces boucles, on en déduit que celui-ci tri le tableau en mettant, pour chaque tour de boucle "while", l'élement le plus petit en premier, et le plus grand à la fin. $P$ est donc de complexité $N * 2$. On peut alors en déduire que au pire, la complexité de cet algorithme est de $4 + N * (4 + (N * 2))$.

    \par\quad En conclusion, on trouve que cette fonction est de complexité quadratique (o(N^2)). Cette algorithme ne comporte pas vraiment d'avantages et son gros inconvéniant est que sa complexité est exponentielle : elle augmente de plus en plus vite. Il serait donc très compliqué de trier un tres grand nombre de valeurs avec. Cependant, elle peut fonctionner sur des petit nombres de valeurs.


    \subsubsection{Complexité de l'algorithme n°2}
    \par\quad 

    \subsubsection{Complexité de l'algorithme n°3}
    \par\quad 



  \subsection{Question 3}
    \par\quad 

  \subsection{Question 4}
    \par\quad 
    
\end{document}