Master de sciences et technologie 1 Mention : mathématiques et applications 4M016 Initiation au C++ 2016-2017 TP 2 : Algorithmes de tri 1 Compilation séparée Le but de cet exercice est de vous familiariser à la compilation séparée permettant de répartir son code sur plusieurs chiers, éventuellement compilable séparément. On va créer trois chiers : "add.cpp" contient la dénition d'une fonction additionnant deux entiers. "add.h" contient la déclaration de la fonction dénie dans "add.cpp". "main.cpp" contient la fonction main qui va appeler la fonction dénie dans "add.cpp". Commencez par : 1) Créez un chier "add.cpp" qui contient la dénition d'une fonction qui ajoute deux nombres entier, appelez-la par exemple "add". 2) Créez un chier "add.h" qui contient la déclaration de la fonction "add". 3) Créez un chier "main.cpp" qui demande l'utilisateur de tapez deux nombres dans le shell et puis qui ache la somme des deux nombre dans le shell. Il vous faudra inclure le chier d'entête à l'aide de la commande #include "add.h". Première méthode de compilation : 4) Compilez tout par la commande g++ main.cpp add.cpp -o main1 et executez votre programme (en tapant./main1). Deuxième méthode de compilation : 5) Compilez d'abord le chier "add.cpp" par la commande g++ -c add.cpp et puis le chier "main.cpp" par la commande g++ -c main.cpp. Renseignez-vous sur le -c dans la commande. Finalement, créez un executable par la commande g++ main.o add.o -o main2. Testez votre programme (tapez./main2). 2 Trois algorithmes de tri On s'intéresse ici au problème de tri d'une suite de N entiers, c'est-à-dire ranger dans l'ordre croissant une suite nie d'entiers initialement placés dans le désordre. Prenons par exemple la suite suivante de 10 entiers naturels 11 54 23 6 7 89 4 2 8 45, 1
on veut donc obtenir au nal : 2 4 6 7 8 11 23 45 54 89. Pour réaliser cela, il existe de nombreux algorithmes de tri. Au cours de cette séance nous allons en voir trois. Nous en verrons d'autres aux séances suivantes. 2.1 Travail demandé : Pour chacune des méthodes de tri ci-dessous, vous écrirez une fonction implémentant l'algorithme correspondant. Cette fonction appellera elle-même, si besoin, des sous-routines de votre invention. Cette fonction prendra En entrée : un int* représentant un tableau d'entiers dans le désordre un int représentant la taille du tableau à trier En sortie : un int* représentant le même tableau d'entiers rangés par ordre croissant Ensuite, étant donné un algorithme de tri, vous écrirez un programme executable (i.e. une fonction main) qui 1) fait une boucle sur N pour N = 10, 20, 50, 100, 200, 500, 1000 et pour chaque N eectue les opérations suivantes : * génère aléatoirement un tableau d'entiers de taille N * appelle l'algorithme de tri en l'appliquant au tableau généré * mesure le temps d'execution en seconde de l'algorithme de tri et stocke le résultat 2) exporte au format de gnuplot les données de la courbe qui donne le temps d'execution en fonction de N, 3) trace la courbe correspondante avec gnuplot, en prenant une échelle logarithmique en abscisse comme en ordonnée. Libre à vous si vous le souhaitez d'utiliser un autre logiciel que gnuplot, mais permettant d'acher des courbes. Pour la génération aléatoire de tableau, on pourra utiliser la routine rand de la librairie standard (voir par exemple : http://www.cplusplus.com/reference/cstdlib/rand/ ). Pour appeler gnuplot ou lancer des commande shell depuis un programme C++, on pourra utiliser system (voir : http://www.cplusplus.com/reference/cstdlib/system/ ). 2.2 Le tri à bulles Ce algorithme naif, très répandu mais inecace, peut être traduit de la façon suivante. On commence par le premier terme. S'il est supérieur au terme suivant, on les échange. 2
11 54 23 6 7 89 4 2 8 45 Ensuite, on regarde le deuxième terme, qui est comparé avec le troisième terme. Si le deuxième terme est supérieur au troisième, on les échange. 11 23 54 6 7 89 4 2 8 45 On continue en passant au troisième terme... jusqu'à ce que l'on soit arrivé à la n de la suite. 11 23 6 7 54 4 2 8 45 89 On vérie aisément qu'à ce stade, le dernier élément (l'élément 10) est l'élément ayant la plus grande valeur de la suite, donc il est bien placé. On renouvelle alors l'opération maintenant sur la suite allant de l'élément 1 à l'élément 9. À la n de cette opération, on aura l'élément 9 qui sera inférieur à l'élément 10 et supérieur à tous les autres. 11 6 7 23 4 2 8 45 54 89 On continue jusqu'à ce que la taille de la sous-suite soit à un et on obtient 2 4 6 7 8 11 23 45 54 89. 2.3 Le tri par insertion Voici un autre algorithme qui est ecace pour trier les petits tableaux, mais pas les grands. Le principe est le suivant. Supposons que les k premiers termes de la suite soient ordonnés par ordre croissant (ici k = 4). 6 11 23 54 7 89 4 2 8 45 L'objectif est d'insérer l'élément k + 1 à la bonne place dans la sous-suite composée des k premiers termes. Pour cela, on échange les éléments k et k + 1, puis k 1 et k... jusqu'à ce que la sous-suite composée des k + 1 premiers termes soit ordonnée. 6 7 11 23 54 89 4 2 8 45 On passe ensuite à l'étape suivante, c'est-à-dire insérer l'élément k + 2 dans la sous-suite composées des k + 1 premiers termes. L'algorithme débute par l'insertion du deuxième élément dans la sous-suite composée du premier terme. 2.4 Le tri par fusion Il s'agit d'un algorithme récursif beaucoup plus ecace basé sur un principe de type "divide and conquer" (diviser pour régner). Cet algorithme s'appuie sur une routine intermédiaire merge (fusion) qu'il faut d'abord introduire avant de pouvoir présenter l'algorithme de tri proprement dit. 3
Présentation de la sous-routine merge Cette routine prend en entrée un int* représentant un tableau d'entiers dans le désordre que nous noterons ici T, et trois int que nous noterons p, q, r tels que p q < r. Elle renvoie en sortie un int* représentant le même tableau d'entiers tel que les nombres T[p], T[p + 1],... T[r] soient rangés par ordre croissant. Le point important est que, pour eectuer cette opération de tri partiel, elle présuppose que la série T[p], T[p + 1],... T[q] d'une part, et la série T[q + 1], T[q + 2],... T[r] d'autre part, sont rangées par ordre croissants. Voici le principe algorithmique de cette routine merge. On compare d'abord T[p] et T[q]. On retient le plus petit des deux nombres, ce qui donne un premier résultat que l'on stocke. Mettons ici qu'il s'agisse de T[p]. On compare ensuite T[p + 1] et T[q]. On retient le plus petit, ce qui donne un deuxième résultat que l'on stocke à la suite du premier résultat, mettons ici T[q]. On compare enuite T[p + 1] et T[q + 1], on retient le plus petit,...et ainsi de suite. Voici ci-dessous un exemple d'application de cet algorithme avec, à gauche les deux soustableaux à fusionner, et à droite le résultat de la fusion, itération par itération. En gris sont colorées les entrées à comparer dans les sous-tableaux. Itération 1 : 6 7 11 23 2 3 9 20 2 Itération 2 : 6 7 11 23 2 3 9 20 2 3 Itération 3 : 6 7 11 23 2 3 9 20 2 3 6 Itération 4 : 6 7 11 23 2 3 9 20 2 3 6 7 Itération 5 : 6 7 11 23 2 3 9 20 2 3 6 7 9 Itération 6 : 6 7 11 23 2 3 9 20 2 3 6 7 9 11 Itération 7 : 6 7 11 23 2 3 9 20 2 3 6 7 9 11 20 23 4
Algorithme merge sort Une fois que l'on a à disposition une sous-routine de fusion, l'algorithme de tri par fusion prend la forme très simple suivante : MergeSort(T, p, r) if(p<r){. q = (p + r)/2. MergeSort(T, p, q). MergeSort(T, q + 1, r). Merge(T, p, q, r) } Dans cet algorithme n désigne la partie entière de n. Pour trier le tableau en entier il sut alors d'appeler MergeSort avec p = 0 et r = longueur(t) -1. 5