Algorithmes de tri PSI* Algorithmes de tri

Transcription

1 Algorithmes de tri I. Position du problème On désigne par tri l opération consistant à ordonner un ensemble d éléments en fonction de clés sur lesquelles est définie une relation d ordre. On se limitera ici à des données stockées dans une liste liste; à chaque élément liste[i] d indice i est associée une clé notée cle(i) qui renvoie une valeur numérique servant à la comparaison. Si le tableau est déjà formé de valeurs numériques, il suffira de prendre cle(i) égale à liste[i]. Dans certains cas, au lieu d une procédure cle qui renvoie une valeur numérique, on peut disposer d une procédure est-plus-petit(i,j) qui permet de comparer les éléments liste[i] et liste[j]. On peut également avoir besoin d une procédure echange (i,j) qui permet d échanger les éléments d indices i et j. Une inversion dans le tableau liste est un couple d indices (i, j) tels que i<j et cle(i)>cle(j). Le tableau sera dit trié s il ne contient aucune inversion (on a défini ici un tri par ordre croissant des clés ; les algorithmes de tri par ordre décroissant s en déduisent facilement). Un algorithme de tri sera dit stable s il ne modifie pas l ordre de deux éléments dont les clés sont égales. Cela peut être un critère important si l on trie selon une certaine clé des éléments déjà triés selon une autre. Pour simplifier les exemples, nous ne considèrerons plus que des tableaux contenant des valeurs numériques. Il n y aura donc pas besoin d implémenter une fonction cle. Ces tableaux seront comme en Python numérotés de 0 à n 1. II. Complexité Un algorithme de tri d une liste de n éléments a une complexité minimale en O(n) : en effet, même si le tableau est déjà trié, il faudra au moins n 1 comparaisons pour s en assurer! La complexité maximale est, elle, d au moins O(n ln n) : en effet, si l on considère l arbre binaire de toutes les comparaisons que peut effectuer l algorithme, cet arbre possède au moins n! feuilles comme le montre l exemple ci-dessous (pour n = 3) : a 1 < a a < a 3 a 1 < a 3 1,, 3 a 1 < a 3, 1, 3 a < a 3 1, 3, 3, 1,, 3, 1 3,, 1 La hauteur h de cet arbre, qui est aussi le nombre minimal de comparaisons à faire dans le cas le plus défavorable, ln n! est donc le plus petit entier tel que h n! soit h = + 1. Or par une banale méthode de comparaison ln série-intégrale, ou en utilisant la formule de Stirling, il est facile d établir ln n! n + n ln n, donc h = O(n ln n). III. Le tri bulle Le principe du tri bulle est le suivant : on part de la fin de la liste et l on regarde les éléments consécutivement, en les échangeant s ils ne sont pas dans l ordre. A la fin d un premier passage sur la liste, l élément le plus petit se retrouve en tête de liste, puis on applique de nouveau le procédé sur la partie de la liste entre le second et le dernier élément etc... C est de là que provient le nom : l algorithme imite la remontée de bulles dans un verre de champagne. Si la liste est de taille n, après n passages, les n éléments seront remontés et classées dans l ordre. Informatique PSI* T.LEGAY Lycée d Arsonval 1/9 5 janvier 017

2 Pseudo-code : Complexité : Algorithme 1 : Tri bulle Données : t : liste d éléments n longueur(t); pour i de 0 à n faire /* invariant de boucle: la liste t[0 : i] est triée */; pour j de n 1 à i + 1 faire si t j 1 > t j alors échanger t j et t j 1 L étude de la complexité du tri bulle est relativement simple. On s intéresse au nombre de comparaisons effectuées par un tri bulle.lors de chaque boucle interne, une comparaison est faite. La boucle interne comprend, pour chaque i, n i 1 itérations, et i varie entre 0 et n. Le nombre total de comparaisons sera donc : n n 1 (n i 1) = i = i=0 i=0 La complexité est donc O(n ). Le nombre ci-dessus est le nombre de comparaisons; le nombre d échanges effectué peut être inférieur. Plus précisément : dans le meilleur des cas, il n y aura aucun échange (liste déjà triée). dans le pire des cas, il y aura autant d échanges que de comparaisons (liste déjà triée, mais en sens inverse). on peut alors chercher la complexité en moyenne. Le nombre d échanges faits est égal au nombre d inversions, puisque chaque échange en supprime une. Il s agit donc de calculer le nombre moyen d inversions parmi toutes les permutations. Pour toute permutation σ = (x 1,..., x n ), notons σ la permutation (x n,..., x 1 ), de sorte que si (i, j) est une inversion dans σ ce n en est pas une dans σ et réciproquement. Comme il y a la somme du nombre d inversions de σ et de σ est couples (i, j) possibles, donc le nombre moyen d inversions et : il s agit de la complexité moyenne, qui est de toutes façons encore un O(n ). 4 Conclusion : Le tri bulle est certainement le plus mauvais algorithme de tri!. Cela vient principalement du fait que chaque élément n est comparé qu à son voisin immédiat. Si par exemple l élément le plus grand du tableau est à la première place mais que le reste du tableau est trié, on atteindra quand même la complexité maximale! IV. Tri par selection Le principe du tri par sélection est le suivant : sélectionner le plus petit élément du tableau, et l échanger avec l élément d indice 1 ; sélectionner le second plus petit élément du tableau, et l échanger avec l élément d indice ; continuer de cette façon jusqu à ce que le tableau soit entièrement trié. L algorithme consiste donc en la recherche de n 1 minimums. Pseudo-code : Informatique PSI* T.LEGAY Lycée d Arsonval /9 5 janvier 017

3 Complexité : Algorithme : Tri par sélection Données : t : liste d éléments n longueur(t); pour i de 0 à n faire /* ici la liste t[0 : i] est triée */; min i; /* recherche de l indice du minimum dans t[i :] */; pour j de i + 1 à n 1 faire si t j < t min alors min j si min i alors échanger t i et t min Le nombre de comparaisons effectuées est facile à calculer puisqu il y a une comparaison par itération de la boucle interne. Cela en fait donc n n 1 1 = i=0 j=i+1 La complexité de l algorithme est donc O(n ). De ce point de vue, il n est pas plus efficace que le tri bulle. Par contre, le tri par sélection n effectue que peu d échanges : on peut montrer que le nombre d échanges est en moyenne un O(n)( alors qu il est un O(n ) dans le tri bulle) : n 1 échanges dans le pire cas, qui est atteint lorsque la liste est déjà triée à l envers ; 0 échange dans le meilleur des cas (liste déjà triée) ; on s intéresse au nombre moyen d échanges : à l étape i de la boucle externe, il reste à trier une liste de taille n i ; il n y aura pas d échange si et seulement si l élément examiné t i est déjà à sa place ; si on (n i 1)! considère toutes les permutations comme équiprobables, la probabilité de cet évènement est (n i)! 1 1 soit. La probabilité d avoir un échange est donc 1 et le nombre moyen d échanges sera égal n i n i n 1 ( à 1 1 ) n 1 = n = n ln n γ + o(1). n i i i=0 i=1 Donc le nombre moyen d échanges est un O(n), ce qui est mieux que le tri bulle. Ce tri est donc intéressant lorsque les éléments sont aisément comparables, mais coûteux à déplacer dans la structure. V. Tri par insertion Le tri par insertion est un algorithme de tri naturel : on ajoute un élément à la fois en le mettant à sa place.c est la méthode utilisée par les joueurs de cartes pour ranger leur main, ou par un enseignant pour ordonner des dossiers ou des copies... Dans l algorithme, on parcourt le tableau à trier du début à la fin. Au moment où on considère le i-ème élément, les éléments qui le précèdent sont déjà triés, et il s agit d insérer cet élément à sa place parmi ceux qui précèdent. Il faut pour cela trouver où l élément doit être inséré en le comparant aux autres, puis décaler les éléments afin de pouvoir effectuer l insertion. En pratique, ces deux actions sont effectuées en une seule passe, qui consiste à faire remonter l élément au fur et à mesure jusqu à rencontrer un élément plus petit. Pseudo-code : Informatique PSI* T.LEGAY Lycée d Arsonval 3/9 5 janvier 017

4 Complexité : Algorithme 3 : Tri par insertion Données : t : liste d éléments n longueur(t); pour i de 1 à n 1 faire /* Ici, t[0 : i] est trié. On va y insérer t[i] */; x t i ; j i 1; tant que (j 0) et (t j > x) faire t j+1 t j ; j j 1; fintq /* la nouvelle place de t[i] est en j + 1 */; t j+1 x Par la même méthode que pour les algorithmes précédents, on montre que le nombre maximum d exécutions de la boucle est (liste triée à l envers) et que sa valeur moyenne est (c est encore le nombre 4 moyen d inversions). C est donc encore un algorithme en O(n ). Cependant il a le gros avantage par rapport aux algorithmes précédents de ne pas faire d échanges, mais seulement des décalages (donc une opération de moins à chaque fois). De plus, dans le meilleur des cas (liste déjà triée), la complexité est en O(n) et surtout, la complexité reste en O(n) si le tableau est presque trié (par exemple, chaque élément est à une distance bornée de la position où il devrait être, ou bien si tous les éléments sauf un nombre borné sont à leur place). Dans cette situation particulière, le tri par insertion surpasse d autres méthodes de tri : par exemple, le tri fusion et le tri rapide (avec choix aléatoire du pivot) sont tous les deux en O(n ln n) même sur une liste déjà triée. Conclusion : Le tri par insertion est considéré comme le tri le plus efficace sur des entrées de petite taille. Il est aussi très rapide lorsque les données sont déjà presque triées. Pour ces raisons, il est utilisé en pratique en combinaison avec d autres méthodes comme le tri rapide. VI. Tri rapide (quicksort) Le tri rapide est une méthode de tri récursive s appuyant sur le principe diviser pour régner. Il a été inventé par Hoare en La méthode consiste à placer un élément du tableau (appelé pivot) à sa place définitive, en permutant tous les éléments de telle sorte que tous ceux qui sont inférieurs au pivot soient à sa gauche et que tous ceux qui sont supérieurs au pivot soient à sa droite. Cette opération s appelle le partitionnement. Pour chacun des sous-tableaux, on définit un nouveau pivot et on répète l opération de partitionnement. Ce processus est répété récursivement, jusqu à ce que l ensemble des éléments soit trié. Pseudo-code : programme principal Algorithme 4 : Tri rapide : programme principal fonction TriRapide( t,debut,fin) si debut < fin alors pivot Partition(t,debut,fin); TriRapide( t,pivot+1,fin) /* L appel initial sera: TriRapide(t,0, len(t) 1) */ Dans cet algorithme, la procédure Partition s occupe de partager le sous-tableau autour d un pivot, et renvoie l indice de ce pivot. Informatique PSI* T.LEGAY Lycée d Arsonval 4/9 5 janvier 017

5 Un problème de complexité spatiale peut se poser : en effet, lors de la récursion, les appels non encore satisfaits sont empilés ; dans un cas particulièrement défavorable, il se pourrait que les partitions successives donnent deux sous-tableaux très inégaux, l un vide et l autre de taille maximum ; à partir du tableau initial, on obtiendrait donc une pile de taille n, soit une complexité spatiale en O(n), ce qui est inacceptable. Une solution à ce problème est de commencer systématiquement par le tableau de plus petite taille. Ainsi, la taille maximale P (n) de la pile lors des appels récursifs vérifiera une relation de récurrence de la forme ( n ) P (n) 1 + P d où P (n) = O(ln n) ce qui est beaucoup mieux. La modification à apporter est simple : Algorithme 5 : Tri rapide : programme principal amélioré fonction TriRapide( t,debut,fin) si debut < fin alors pivot Partition(t,debut,fin); si pivot-debut fin - pivot alors TriRapide( t,pivot+1,fin); TriRapide( t,pivot+1,fin); /* L appel initial sera: TriRapide(t,0, len(t) 1) */ Enfin, on peut remarquer que, puisque le second appel récursif est la dernière instruction (récursivité terminale), il peut être avantageusement remplacé par une structure itérative (boucle tant...que). Cela donne le programme suivant : Algorithme 6 : Tri rapide : programme principal encore amélioré fonction TriRapide( t,debut,fin) tant que debut < fin faire pivot Partition(t,debut,fin); si pivot-debut fin - pivot alors debut pivot +1; TriRapide( t,pivot+1,fin); fin pivot 1; fintq /* L appel initial sera: TriRapide(t,0, len(t) 1) */ Pseudo-code : programme partitionnement Le partitionnement est la partie la plus délicate. Une approche assez simple est la suivante : on choisit arbitrairement comme pivot le dernier élément du sous-tableau ; on place tous les éléments inférieurs au pivot en début du sous-tableau ; on place le pivot à la fin des éléments déplacés. Cela donne l algorithme suivant : Informatique PSI* T.LEGAY Lycée d Arsonval 5/9 5 janvier 017

6 Complexité : Algorithme 7 : Partitionnement : première version Résultat : indice du pivot fonction Partition( t,debut,fin) valeur t fin ; p debut; pour i de debut à fin 1 faire si t i valeur alors échanger t i et t p ; p p + 1 échanger t p et t fin ; renvoyer p On s intéresse ici au nombre de comparaisons effectuées, qui majore de toutes façons le nombre d échange. La complexité, en nombre de comparaisons, de la fonction de partition Partition(t,debut,fin) est exactement fin debut. Étudions la complexité en moyenne du tri rapide, en supposant qu à chaque étape la position du pivot est équiprobable pour toutes les valeurs. Notons C(k) le nombre de comparaisons pour un tableau de taille k. Lors de l appel initial de Trirapide, la fonction Partition effectue n 1 comparaisons : si le pivot est situé à la position k, il y aura C(k) comparaisons pour la partie gauche du tableau et C(n k 1) pour la partie droite. Cela donne, en moyenne : d où C(n) = 1 n 1 (C(k) + C(n 1 k)) + n 1 = n 1 C(k) + n 1 n n k=0 n 1 nc(n) = C(k) +. En considérant cette égalité aussi au rang n 1 et en la soustrayant à la précédente on obtient : k=0 nc(n) (n 1)C(n 1) = C(n 1) + (n )(n 1) k=0 d où puis nc(n) (n + 1)C(n 1) = (n 1) C(n) C(n 1) = n 1 n + 1 n n(n + 1) = 4 n + 1 n d où en additionnant, après télescopage, et en notant H n la n-ième siomme partielle de la série harmonique : C(n) n + 1 = 4(H n+1 1) H n = 4(ln(n + 1) + γ 1) (ln(n) + γ) + o(1) n + n ln(n). La complexité en moyenne du tri rapide pour les comparaisons est donc en O(n ln(n)). Cependant : dans le pire des cas, c est-à-dire quand le pivot choisi est le plus petit élément, ou le plus grand, la partition se fera en laissant un des cotés vide, et l autre avec n 1 éléments. La complexité vérifie alors la relation de récurrence C(n) = C(n 1) + n 1 qui se résout (assez) facilement, et donne C(n) n!! AIE!! Pour cette raison, il existe pléthore d autres méthodes de partitionnement ; la plus facile à écrire consiste à choisir un pivot aléatoire. On obtiendra donc un algorithme du genre : Informatique PSI* T.LEGAY Lycée d Arsonval 6/9 5 janvier 017

7 Algorithme 8 : Partitionnement : deuxième version Résultat : indice du pivot fonction Partition( t,debut,fin) x entier aléatoire entre debut et fin; échanger t x et t fin ; valeur t fin ; p debut; pour i de debut à fin 1 faire si t i valeur alors échanger t i et t p ; p p + 1 échanger t p et t fin ; renvoyer p Une autre solution possible pour le choix du pivot, elle aussi très simple à mettre en oeuvre, est de choisir l indice de l élément médian parmi les trois éléments d indices debut, fin et (debut + fin)/. Je vous encourage vivement à le faire! Un ultime raffinement : Il semble clair que le programme exposé ci-dessus est trop lourd pour des petits tableaux ; pour cette raison, il convient d arrêter la récursion dès que la taille des sous-tableaux devient inférieur à un certain seuil. Lorsque ce seuil est atteint, on fera appel au tri par insertion. Certaines études théoriques et des essais pratiques ont situés ce seuil entre 8 et 0. Le programme définitif sera donc le suivant : Algorithme 9 : Tri rapide : programme principal, version finale. fonction TriRapide( t,debut,fin) seuil = 10; tant que fin - debut > seuil faire pivot Partition(t,debut,fin); si pivot-debut fin - pivot alors debut pivot +1; TriRapide( t,pivot+1,fin); fin pivot 1; fintq TriInsertion( t,debut,fin) /* L appel initial sera: TriRapide(t,0, len(t) 1) */ VII. Tri fusion (merge sort) Le tri fusion est, elle aussi, une méthode de tri récursive s appuyant sur le principe diviser pour régner. Elle consiste à séparer les données en deux parties presque égales, puis à traiter chaque partie et enfin à les rassembler. L efficacité de l algorithme vient du fait que deux listes triées peuvent être fusionnées en temps linéaire. Le tri fusion a une efficacité comparable à celle du tri rapide, mais il n opère pas en place : une zone temporaire de données supplémentaire de taille égale à celle de l entrée est nécessaire. Il est donc plutôt utilisé pour le tri de données externes. Pseudo-code : programme principal Informatique PSI* T.LEGAY Lycée d Arsonval 7/9 5 janvier 017

8 Algorithme 10 : Tri fusion : programme principal Données : t liste des éléments à trier Résultat : la liste triée fonction TriFusion( t) n longueur(t); si n <= 1 alors renvoyer t p n ; renvoyer Fusionner( T rif usion(t[0 : p]), T rif usion(t[p :])) On pourrait envisager une implémentation récursive de la procédure Fusionner, mais cela n est pas du tout efficace à cause des nombreuses recopies de listes qui sont faites, et surtout, le nombre d appels récursifs est égal à la taille du plus grand des deux tableaux, ce qui est inacceptable : Algorithme 11 : Fusionner : version récursive moche Données : deux listes triées t 1 et t Résultat : liste triée formée de la fusion des deux fonction Fusionner(t 1, t ) si t 1 est vide alors renvoyer t si t est vide alors renvoyer t 1 si t 1 [0] < t [0] alors renvoyer [t 1 [0]] + Fusionner(t 1 [1 :], t ) renvoyer [t [0]] + Fusionner(t 1, t [1 :]) Une version itérative, qui utilise une liste auxiliaire, est de loin préférable : Algorithme 1 : Fusionner : version itérative Données : deux listes triées a et b Résultat : liste triée formée de la fusion des deux fonction Fusionner( a, b) tmp liste vide ; i 0; j 0 ; tant que (i < len(a) ) et (j < len(b)) faire si a i b j alors ajouter a i à la fin de tmp; i i + 1 ajouter b j à la fin de tmp ; j j + 1 fintq si i = len(a) alors ajouter à la fin de tmp les éléments de la liste b à partir de b j ajouter à la fin de tmp les éléments de la liste a à partir de a i renvoyer tmp; Informatique PSI* T.LEGAY Lycée d Arsonval 8/9 5 janvier 017

9 Complexité maximale : Supposons d abord que la taille du tableau initial est n = p. On a donc alors (complexité en nombre de tests) : ( ) N C(N) = C + N ( et C(1) = 1) (deux appels récursifs avec des tableaux de taille divisée par, plus le coût de la fusion). Si on réécrit : En posant u p = C(p ) p on a alors : { 1 sip = 0 u p = u p On reconnaît une suite arithmétique, dont on peut calculer le terme général u p C( p ) = p u p = p. p + p. Puisque p = log (n) on en tire : C(n) = O(n ln(n)). = 1 + p, d où il vient Si maintenant le tableau n est pas de taille p, il suffit d encadrer n entre deux puissances de successives : La fonction de complexité étant croissante, on a donc p n < p+1 C( p ) C(n) C( p+1 ) ce qui permet d en déduire que l on a encore C(n) = O(n ln(n)). Informatique PSI* T.LEGAY Lycée d Arsonval 9/9 5 janvier 017