Algorithmes de tri (1/2) Algorithmes de tri (2/2)

Transcription

1 Algorithmes de tri (1/2) Problématique : étant donné une structure linéaire (tableau, liste, etc) contenant des valeurs d'un type ordonné, il faut trier les éléments en ordre croissant (ou décroissant). Il existe des dizaines d'algorithmes répondant à ce problème, utilisant quelques principes de base auxquels on ajoute des variantes On peut distinguer : les tris internes qui trient les éléments dans la structure qui les contient (tableau, liste,...) ou au pire utilise une structure annexe de même type les tris externes utilisés lorsque la quantité d'éléments à trier est telle qu'ils ne tiennent pas en mémoire vive et qu'il faut stocker des éléments dans des fichiers ou des tables de bases de données 1 Algorithmes de tri (2/2) Propriétés des algorithmes de tri : complexité en temps et en espace stabilité : l'algorithme ne modifie pas l'ordre initial des éléments égaux par comparaison tri sur place ou pas : l'algorithme n'utilise pas de mémoire supplémentaire (hormis éventuellement quelques indices de boucle ou booléens), les éléments sont triés directement dans la structure de données La plupart des algorithmes de tri utilisent la comparaison d'éléments 2 à 2 on montre que le nombre minimum de comparaisons à effectuer est nlog(n) si n est la taille de la structure. Les algorithmes en O(n 2 ) sont donc peu efficaces, ceux au pire en O(nlog(n)) sont optimaux il existe des tris linéaires, mais ils n'utilisent pas la comparaison et sont limités à des cas très particuliers (tris de nombres dont on connait des propriétés statistiques) 2

2 Tri à bulle (1/7) Principe du tri à bulle (bubble sort) : l'élément le plus grand remonte au bout du tableau, comme une bulle de champagne, puis on recommence pour que le deuxième plus grand remonte, etc. L'écriture de l'algorithme s'inspire de l'algorithme séquentiel qui vérifie si un tableau est trié. Algorithme : i désigne la dernière case à traiter fonction sans retour tribulle(entier[] tab){ entier i,j,temp; pour (i allant de tab.longueur-2 à 1 pas -1) faire pour (j allant de 0 à i pas 1) faire si (tab[j] > tab[j+1]) alors temp <- tab[j]; tab[j] <- tab[j+1]; tab[j+1] <- temp; pour pour 3 Tri à bulle (2/7) Exemple : trier en ordre croissant le tableau suivant premier tour de la première boucle (sur i) j=0 j=1 j=2 j=3 j=4 j=5 j=

3 Tri à bulle (3/7) deuxième tour de la première boucle (sur i) troisième tour de la première boucle (sur i) quatrième tour de la première boucle (sur i) Problème : l'algorithme va faire 3 tours supplémentaires de la boucle sur i, inutilement 5 Tri à bulle (4/7) Complexité du tri à bulle en fonction de la taille n du tableau : la remontée du plus grand élément utilise (n-1) comparaisons, la remontée du deuxième plus grand utilise (n-2), etc. La complexité sera donc toujours proportionnelle à (n-1)+(n-2) = n*(n-1)/2 soit O(n 2 ). Le tri à bulle est en place et l'algorithme donné ici est stable (il serait instable si on utilisait au lieu de >) Une amélioration possible du tri bulle consiste à utiliser une variable booléenne drapeau qui permet de stopper le tri si plus aucune permutation n'a lieu 6

4 Tri à bulle (5/7) fonction sans retour tribulle(entier[] tab){ entier i,j,temp; booleen b; b <- faux; i <- tab.longueur-2; tantque ((non b) et (i > 0)) faire b <- vrai; pour (j allant de 0 à i pas 1) faire si (tab[j] > tab[j+1]) alors temp <- tab[j]; tab[j] <- tab[j+1]; tab[j+1] <- temp; b <- faux; pour i <- i-1; tantque Remarques : la complexité au pire et en moyenne reste en O(n 2 ) mais est linéaire au mieux cette amélioration n'est efficace que si le tableau est déjà «un peu» trié et qu'il devient trié «assez vite» 7 Tri à bulle (6/7) Une autre amélioration possible du tri bulle est le tri Boustrophedon (du nom des écritures qui changent de sens à chaque ligne) : on parcourt le tableau de gauche à droite, en faisant remonter l'élément le plus grand on redescend le tableau de droite à gauche, en faisant descendre le plus petit on recommence en ignorant les 2 éléments déjà triés la complexité au pire et en moyenne est toujours en O(n 2 ) mais est réduite du fait qu'on peut exploiter les bonnes positions des petits éléments comme des plus grands 8

5 Tri à bulle (7/7) Tri par la méthode du tri à bulle de tableaux d'entiers générés aléatoirement 9 Tri sélection (1/3) Principe du tri sélection (ou tri par extraction) : on parcourt le tableau pour trouver le plus grand élément, et une fois arrivé au bout du tableau on y place cet élément par permutation. Puis on recommence sur le reste du tableau. Algorithme : i désigne la dernière case à traiter fonction sans retour triselection(entier[] tab){ entier i,j,temp,pg; debut i <- tab.longueur-1; tanque (i > 0) faire pg <- 0; pour (j allant de 0 à i pas 1) faire si (tab[j] > tab[pg]) alors pg <- j; pour temp <- tab[pg]; tab[pg] <- tab[i]; tab[i] <- temp; i <- i-1; tantque 10

6 Tri sélection (2/3) Complexité du tri sélection : à chaque tour de la boucle tantque, on fait i tours de boucle pour. La complexité sera donc dans tous les cas proportionnelle à (n-1)+(n-2) =n*(n-1)/2 et donc en O(n 2 ). Remarque : le tri sélection utilise une variable de plus que le tri bulle pour stocker l'indice du plus grand élément, mais il utilise moins d'instructions (une seule permutation par parcours du tableau) Le tri sélection est en place et l'algorithme donné ici est stable (il serait instable si on utilisait au lieu de >) Le tri sélection peut être amélioré en positionnant à chaque parcours du tableau le plus grand et le plus petit élément, selon le même principe que celui utilisé pour le tri Boustrophédon. dans ce cas, on fera 2 fois moins de tours de boucle tantque (on trie 2 éléments à chaque tour) mais à chaque tour, on effectuera plus d'opérations, la complexité reste donc quadratique mais s'améliore 11 Tri sélection (3/3) Tri par la méthode du tri sélection de tableaux d'entiers générés aléatoirement 12

7 Tri insertion (1/2) Principe du tri insertion : on prend deux éléments qu'on trie dans le bon ordre, puis un 3e qu'on insère à sa place parmi les 2 autres, puis un 4e qu'on insère à sa place parmi les 3 autres, etc. C'est la méthode la plus utilisée pour trier des dossiers, des cartes à jouer,... Algorithme : i représente le nombre d'éléments triés fonction sans retour triinsertion(entier[] tab){ entier i, j, val; debut pour (i allant de 1 à tab.longueur-1 pas 1) faire val <- tab[i]; j <- i; tantque ((j > 0) et (tab[j-1] > val)) faire tab[j] <- tab[j-1]; j <- j-1; tantque tab[j] <- val; pour 13 Tri insertion (2/2) Complexité du tri insertion : au pire, si le tableau est trié en ordre inverse, à chaque tour de la boucle pour, on fait i tours de boucle tantque. La complexité au pire sera donc proportionnelle à (n-1) =n*(n-1)/2 et donc en O(n 2 ). au mieux, si le tableau est déjà trié, on fera une seule comparaison par élément, sans permutation, sauf pour le premier élément. La complexité au mieux est donc proportionnelle à (n-1) et linéaire. en moyenne, chaque élément sera inséré au milieu de ceux déjà triés, le nombre de comparaisons sera donc de 0+1+3/2+...+n/2 soit n*(n+1)/4 et la complexité moyenne est donc en O(n 2 ). Le tri par insertion est en place et l'algorithme donné ici est stable (il serait instable si on utilisait au lieu de >) Remarque : le tri insertion est donc environ 2 fois plus rapide que le tri sélection 14

8 Tris quadratiques Comparaison des tris quadratiques sur des tableaux d'entiers générés aléatoirement 15 Tri rapide (1/5) Principe du tri rapide (quicksort, tri de Hoare) : on prend le premier élément (le pivot), on le met à sa place en plaçant à sa gauche les éléments plus petits que lui et à sa droite les éléments plus grands que lui. Puis on répète l'opération d'une part sur le sous tableau de gauche, d'autre part sur le sous-tableau de droite. Algorithme : on partitionne le tableau autour de la valeur contenue dans la première case, puis on appelle l'algorithme sur chacune des sous-parties. Il nous faut donc : une fonction qui partitionne une certaine section [a,b] du tableau en plaçant au les éléments plus petits que tab[a], puis tab[a], puis les éléments plus grands ou égaux à tab[a] et retourne l'indice de tab[a] dans le tableau partitionné (au départ, a vaudra 0 et b vaudra tab.longueur-1) une fonction de tri proprement dit qui appelle la fonction précédente puis lance des appels récursifs sur les sous-parties 16

9 Tri rapide (2/5) fonction avec retour entier partition(entier[] tab, entier a, entier b){ entier pivot,i,temp; pivot <- a; pour (i allant de a+1 à b pas 1) faire si (tab[i] < tab[pivot]) alors temp <- tab[i]; tab[i] <- tab[pivot+1]; tab[pivot+1] <- tab[pivot]; tab[pivot] <- temp; pivot <- pivot+1; pour return pivot; // cette fonction trie les éléments de tab d'indices compris entre a et b inclus fonction sans retour trirapide(entier[] tab, entier a, entier b){ entier pivot; si (b > a) alors pivot <- partition(tab,a,b); trirapide(tab,a,pivot-1); trirapide(tab,pivot+1,b); 17 Tri rapide (3/5) Exemple d'exécution de la fonction de partitionnement : i=1 et pivot= i=2 et pivot= i=3 et pivot= i=4 et pivot= i=5 et pivot= i=6 et pivot=3 i=7 et pivot= L'indice du pivot retourné est 4 18

10 Tri rapide (4/5) Complexité du tri rapide : la fonction de partitionnement est linéaire de la forme a*n où a est une constante. au mieux, dans le cas où le partitionnement coupe toujours le tableau en deux parties égales (à 1 près), la complexité c(n) de la fonction de tri est telle que c(n) = a*n + 2*c(n/2) + b où b est une constante. Dans ce cas, on a c(n) = O(n*log(n)). au pire, dans le cas où le partitionnement conduit systématiquement à ce qu'une des parties soit vide, la complexité c(n) de la fonction de tri est telle que c(n) = a*n + c(n-1) + b où b est une constante. Dans ce cas, on a c(n) = O(n 2 ). en moyenne, on peut montrer que c(n) = O(n*log(n)). Le tri rapide n'est pas optimum dans tous les cas, mais en moyenne, il est bien plus rapide que les tris quadratiques Le tri rapide est en place, mais l'algorithme donné ici n'est pas stable 19 Tri rapide (5/5) Améliorations possibles : quand le tableau est déjà «un peu trié», il vaut mieux choisir comme pivot l'élément du milieu du tableau, pour équilibrer les parties fonction avec retour entier partition(entier[] tab, entier a, entier b){ entier pivot,i,temp; temp = tab[a]; tab[a] = tab[(a+b)/2]; tab[(a+b)/2] = temp; pivot <- a;... quand le tableau n'est pas «un peu trié», on peut découvrir l'élément médian (tel que la moitié des éléments du tableau sont plus petits, et la moitié plus grands, à 1 près) avec un algorithme linéaire. Cette amélioration assure donc une complexité au pire en O(n*log(n)) au tri rapide. quand les parties à trier sont petites, il peut être plus rapide d'utiliser un tri par sélection pour les trier car ce tri est plus rapide sur de petits tableaux... 20

11 Tri fusion (1/3) Principe du tri fusion : on découpe le tableau en deux, on trie chacune des 2 parties, puis on fusionne les parties triées en respectant l'ordre. Algorithme : il nous faut donc une fonction qui fusionne deux sections contigues du tableau. Le plus simple est d'utiliser des tableaux supplémentaires (mais il est possible de faire du tri fusion en place). une fonction de tri proprement dit qui lance des appels récursifs sur les sousparties puis appelle la fonction précédente 21 Tri fusion (2/3) // cette fonction fusionne les parties de tab d'indices dans [a,b] et [b+1,c], // en supposant que les éléments de ces parties soient triés en ordre croissant. fonction sans retour fusion(entier[] tab,entier a, entier b, entier c){ entier i,j,k; entier[b-a+1] t1; int[c-b] t2; pour (i allant de 0 à t1.longueur-1 pas 1) faire t1[i] <- tab[a+i]; pour pour (j allant de 0 à t2.longueur-1 pas 1) faire t2[j] <- tab[b+1+j]; pour i <- 0; j <- 0; k <- a; tantque (k <= c) faire si (i >= t1.longueur) alors tab[k] <- t2[j]; j <- j+1; sinon si (j >= t2.longueur) alors tab[k] <- t1[i]; i <- i+1; sinon si (t1[i] <= t2[j]) alors tab[k] <- t1[i]; i <- i+1; sinon tab[k] <- t2[j]; j <- j+1; k++; tantque 22

12 Tri fusion (3/3) fonction sans retour trifusion(entier[] tab, entier a, entier b){ si (b>a) alors trifusion(tab,a,(a+b)/2); trifusion(tab,((a+b)/2)+1,b); fusion(tab,a,(a+b)/2,b); Complexité du tri-fusion : la complexité de la fusion est linéaire de la forme a*n où a est une constante la complexité du tri est c(n) = c(n/2) + c(n/2) + a*n + b où b est une constante donc c(n) = O(n*log(n)) dans tous les cas Le tri fusion est donc optimum en complexité, mais généralement, il est moins rapide que le tri rapide, car il duplique le tableau. On peut optimiser le tri en ne dupliquant qu'une des deux parties. Le tri fusion est stable mais la version proposée ici n'est pas en place (il est possible d'en écrire des versions en place) 23 Tris quasilinéaires Comparaison des tris quasilinéaires sur des tableaux d'entiers générés aléatoirement 24