IFT2810 Automne 2008

Algorithmes de tri
Le tri dun ensemble de donn ees est lune des taches les plus courantes en informatique. Il existe plusieurs algorithmes connus de tri. Certains ont une complexit e en O(n2 ). Le plus ecace (quick sort) a une complexit e en O(n log2 (n)). Ces algorithmes peuvent etre utilis es, soit pour trier des el ements en ordre croissant, soit en ordre d ecroissant. Si lordre nest pas sp eci e, alors lordre croissant est consid er e par d efaut.

Tri par insertion

` Cest lun des algorithmes les plus utilis es pour le tri. Imaginez une main de carte. A chaque fois que le joueur prend une nouvelle carte, il lintroduit dans sa main de telle sorte quelle reste ordonn ee. Le tri par insertion est bas e sur cette id ee dinsertion dans une liste ordonn ee. La liste ` a trier est divis ee en deux : la partie gauche est tri ee, et la partie droite est ` non-tri ee. A chaque passage, le premier el ement de la partie non-tri ee est introduite dans la partie tri ee, de telle sorte que cette derni` ere reste tri ee. Pour une liste de n el ements, n 1 passages sont n ecessaires. La complexit e de lalgorithme est donc en O(n2 ). Dans lalgorithme suivant, on consid` ere que les indices dun tableau commencent ` a 0, i.e. le premier el ement de la liste est ` a lindice 0. dernier est lindice du dernier el ement du tableau.
Algorithme triInsertion (liste <tableau>, dernier <entier>) 1. Pour (courant := 1 a dernier) Faire 2. element := liste[courant] ; 3. parcours := courant-1 ; 4. Tant que (parcours 0 Et element < liste[parcours]) Faire 5. liste[parcours+1] := liste[parcours] ; 6. parcours := parcours-1 ; 7. Fin Tant que 8. liste[parcours + 1] := element ; 9. Fin Pour

Lalgorithme triInsertion contient deux boucles. La boucle 1 parcourt le tableau du d ebut ` a la n. Elle est donc ex ecut ee n fois. La boucle 4 parcourt la premi` ere partie tri ee du tableau. Dans le pire des cas, toute la premi` ere partie de tableau est parcourue. Dans le cas moyen, la moiti e de la premi` ere partie de tableau est parcourue. La complexit e dans le pire des cas du tri par insertion est d ecrit par la fonction f (n) = n+1 2 n( 2 ). Cest donc un algorithme en O(n ). 1

Avantages du tri par insertion : M ethode naturelle, facile ` a programmer. De plus, la m ethode est dautant plus rapide que la liste ` a tri ee est presque ordonn ee : la m ethode est plus ecace pour une liste presque tri ee que pour une liste dans un ordre al eatoire. Structure de donn ees : M ethode aussi ecace si la liste ` a tri ee est repr esent ee par un tableau ou par une liste cha n ee.

Tri par s election

Un d esavantage du tri par insertion est que, m eme si une liste est presque tri ee, lintroduction dun nouvel el ement dans cette liste peut n ecessiter le mouvement de la plupart des el ements de la liste. Si la liste ` a trier est tr` es grande, ce mouvement de tous les el ements ` a chaque introduction dun nouvel el ement dans la liste peut etre tr` es co uteux. Il serait souhaitable de pouvoir imm ediatement placer un el ement ` a sa place nale. Cest lavantage du tri par s election. La liste ` a trier est divis ee en deux : la partie gauche est tri ee, et la partie droite est non-tri ee. De plus, tous les el ements de la partie gauche sont plus petits (ou egaux) que les ` chaque passage, l el ements de la partie droite. A el ement minimal de la partie non-tri ee est echang e avec la premier el ement de la liste non-tri ee. Ainsi, la liste tri ee cro t de 1 el ement. Pour une liste de n el ements, n 1 passages sont n ecessaires. La complexit e de lalgorithme est donc en O(n2 ).

Algorithme triSelection (liste <tableau>, dernier <entier>) 1. Pour (courant := 0 a dernier) Faire 2. plusPetit := courant ; 3. Pour (parcours := courant+1 a dernier) Faire 4. Si (liste[parcours] < liste[plusPetit]) 5. plusPetit := parcours ; 6. Fin Si 7. Fin Pour 8. temp := liste[courant] ; 9. liste[courant] := liste[plusPetit] ; 10. liste[plusPetit] := temp ; 11. Fin Pour

Structure de donn ees : La m ethode est appropri ee si la liste est repr esent ee par un tableau. Pas appropri ee si la liste est repr esent ee par une liste cha n ee.

3
3.1

Tri par echange

Tri ` a bulles

La liste ` a trier est divis ee en deux : la partie gauche est tri ee, et la partie droite est ` non-tri ee. On eectue au plus n 1 passages. A chaque passage, l el ement minimal de la partie non-tri ee se retrouve echang e avec la premier el ement de la liste non-tri ee. Ainsi, la liste tri ee cro t de 1 el ement. La di erence entre le tri ` a bulles et le tri par s election, est que le tri ` a bulle compare chaque paire (u,v) de cases cons ecutives du tableau non tri e en ` chaque fois que u > v , u et v sont commen cant par la n du tableau. A echang es. De ce fait, ` a la n dun passage, on est s ur que le plus petit el ement de la partie non-tri ee sera au d ebut de cette partie. Le fait de comparer chaque paire de cases cons ecutives permet de faire moins de passages que le tri par s election : si au cours dun passage aucun echange na et e eectu e, alors la liste est tri ee et on sarr ete. La complexit e dans le pire des cas est toujours O(n2 ), mais dun point de vue pratique, le tri ` a bulles est plus rapide.

Algorithme triBulles (liste <tableau>, dernier <entier>) 1. courant := 0 ; 2. trie := faux ; 3. Tant que (courant dernier Et trie=faux) Faire 4. trie := vrai ; 5. Pour (parcours:=dernier a courant+1) Faire 6. Si (liste[parcours] < liste[parcours-1]) 7. trie := faux ; 8. echange (liste, parcours, parcours-1) ; 9. Fin Si 10. Fin Pour 11. courant := courant+1 ; 12. Fin Pour

3.2

Quicksort

Cest un tri par echange plus ecace que le tri ` a bulles. Le probl` eme de ce dernier est quil faut un grand nombre d echanges pour placer un el ement ` a la bonne place. Quicksort n ecessite moins d echanges. ` chaque A etape, lalgorithme s electionne un el ement particulier du tableau : le piv ot. Le tableau est alors divis e en trois parties : les el ements plus petits que le piv ot, le piv ot, et les el ements plus grands que le piv ot. Autrement dit, le piv ot est plac e` a sa bonne position. On recommence ensuite, r ecursivement, pour la partie gauche et la partie droite du tableau. On pourrait prendre comme el ement piv ot le premier, le dernier, ou tout autre el ement du tableau, et ensuite le placer ` a la bonne position. En g en eral cest l el ement du milieu qui est s electionn e, et permut e avec les el ements de d ebut et de n. Ici on suppose, par simplicit e, que le piv ot est le premier el ement de la liste. Pour illustrer la m ethode, consid erons la liste : 3

75 70 65 84 98 78 100 93 55 61 81 68 ` cette On veut placer le piv ot (75) ` a sa place nale dans la liste. A etape tout ce quon veut cest avoir les el ements plus petit que le piv ot avant le piv ot, et les el ements plus grands apr` es. On eectue les etapes suivantes : On parcourt la liste de gauche ` a droite ` a partir du piv ot ` a lindice l, et on sarr ete d` es quon arrive ` a un indice i contenant une valeur plus grande que le piv ot ; 75 |l 70 65 84 |i 98 78 100 93 55 61 81 68 |r On parcours le tableau de droite ` a gauche et on sarr ete d` es quon arrive ` a un indice j contenant une valeur plus petite que le piv ot ; 75 |l 70 65 84 98 78 100 93 55 61 81 68|j |r On echange les valeurs aux indices i et j . Les deux parties du tableau, de 1 ` a i, et de j ` a r sont correctes : i.e. tous les el ements de la 1` ere partie sont plus petits que le piv ot, et tous les el ements de la deuxi` eme partie sont plus grands que le piv ot. 75 70 65 68 |l 98 78 100 93 55 61 81 |r 84 On refait la m eme chose dans le sous-tableau [l + 1..r 1]. 75 70 65 68 |l 98 78 100 93 55 61 81 |r 84 75 70 65 68 61 |l 78 100 93 55 |r 98 81 84 75 70 65 68 61 |l 78 100 93 55 |r 98 81 84 75 70 65 68 61 55 |l 100 93 |r 78 98 81 84 75 70 65 68 61 r 55 |l 100 93 |r 78 98 81 84 Lorsque les deux pointeurs gauche et droit se retrouvent ` a la m eme place ou se croisent, il ne reste plus qu` a placer le piv ot ` a la bonne place par un simple echange. 55 70 65 68 61 75 100 93 78 98 81 84 Knuth a montr e que cette proc edure est ecace pour des listes susemment longues. Lorsque les listes ` a trier sont courtes (moins que 16 el ements), il est plus ecace dutiliser le simple tri par insertion. Cependant, il faut g en eraliser ce dernier algorithme pour trier un sous-tableau quelconque, ne commen cant pas forc ement ` a lindice 0. La g en eralisation est d ecrite ci-dessous. 4

Algorithme quickInsertion (liste <Tableau>, premier <entier>, dernier <entier>) premier et dernier sont les deux indices d enissants le sous-tableau de liste ` a trier

1. 2. 3. 4. 5. 6. 7. 8. 9.

Pour (courant := premier +1 a dernier) Faire element := liste[courant] ; parcours := courant -1 ; Tant que (parcours >= premier Et element < liste[parcours]) Faire liste[parcours+1] := liste[parcours] ; parcours := parcours-1 ; Fin Tant que liste[parcours+1] := element ; Fin Pour

Nous avons maintenant tous les el ements pour d ecrire lalgorithme Quicksort r ecursif.

Algorithme quickSort (liste <Tableau>, gauche <entier>, droit <entier>)

Si liste trop courte, utiliser le tri par insertion 1. Si (droit - gauche <= tailleMin) 2. quickInsertion (liste, gauche, droit) ; 3. Sinon 4. pivot := liste[gauche] ; 5. triGauche := gauche+1 ; 6. triDroit := droit ; 7. Tant que (triGauche <= triDroit) 8. Tant que (liste[triGauche]<pivot) 9. triGauche := triGauche+1 ; 10. Fin Tant que 11. Tant que (liste[triDroit]>=pivot) 12. triDroit := triDroit-1 ; 13. Fin Tant que 14. Si (triGauche <= triDroit) 15. echange(liste, triGauche, triDroit) ; 16. triGauche := triGauche+1 ; 17. triDroit := triDroit-1 ; 18. Fin Si 19. Fin Tant que Placer le pivot a la bonne place 20. liste[gauche] := liste[triGauche - 1] ; 21. liste[triGauche-1] := pivot ; Recursions dans les deux parties du tableau 22. Si (gauche < triDroit) 23. quickSort(liste, gauche, triDroit-1) ; 24. Fin Si 25. Si (triGauche < droit) 26. quickSort(liste, triGauche, droit) ; 27. Fin Si 28. Fin Si

Chaque passage dans la boucle 8. a une complexit e proportionnelle ` a la taille du tableau ` trier. Si le pivot est bien choisit (situ a e` a peu pr` es au milieu du tableau), la taille du tableau est divis ee par deux ` a chaque etape. La complexit e moyenne de lalgorithme est donc en O(n log2 n). Par contre, la complexit e dans le pire des cas est en O(n2 ). Choix du piv ot : Le choix du premier el ement comme piv ot est correct si on a aaire ` a une liste al eatoire. Si la liste est presque tri ee ou presque tri ee dans le sens inverse, alors un meilleur choix est de prendre l el ement du milieu.

Tri par fusion

Cest une autre m ethode diviser pour reigner. Comme pour Quicksort, la liste ` a trier est subdivis ee en deux parties. Chaque partie est tri ee s epar ement, et ensuite fusionn ee. Contrairement ` a Quicksort, la partie subdivision en deux parties est directes : on prend simplement le milieu de la liste. Cest la fusion qui demande plus de travail. La proc edure r ecursive du tri par fusion est d ecrite ci-dessous : triFusion(tableau) Si tableau a au moins deux el ements subdiviser le tableau en deux sous-tableaux T1 , T2 ; triFusion(T1 ) ; triFusion(T2 ) ; fusion(T1 , T2 ) ; La fusion de deux sous-tableaux tri es se fait de telle sorte que le tableau r esultat soit tri e. Dans lalgorithme suivant, les deux tableaux ` a fusionner sont T1 et T2 , et le tableau r esultat est T . n1 , n2 sont respectivement le nombre d el ements de T1 et T2 .

Algorithme fusion (T, T1 , T2 , n1 , n2 ) 1. i = i1 = i2 = 0 ; 2. Tant que (i1 < n1 et i2 < n2 ) 3. Si (T1 [i1 ] < T2 [i2 ]) 4. T [i] = T1 [i1 ] ; 5. i1 = i1 + 1 ; 6. Sinon 7. T [i] = T2 [i2 ] ; 8. i2 = i2 + 1 ; 9. Fin Si 10. i = i + 1; 11. Fin Tant que 12. Si (i1 < n1 1) 13. Pour (j = i1 a n1 1) Faire 14. T [i] = T1 [j ] ; 15. i = i + 1; 16. Fin Pour 17. Sinon Si (i2 < n2 1 18. Pour (j = i2 a n2 1) Faire 19. T [i] = T2 [j ] ; 20. i = i + 1; 21. Fin Pour 22. Fin Si

Plut ot que de passer trois tableaux en param` etres de fusion, il sut de passer le tableau initial, et deux indices indiquant le d ebut et la n du sous-tableau ` a trier. On a quand m eme besoin, dans ce cas, dun tableau interm ediaire, d eclar e comme variable locale.

Algorithme fusion (T , deb, f in) 1. mid = (deb + f in)/2 ; 2. i = 0 ; i1 = deb ; i2 = mid + 1 ; 3. Tant que (i1 < mid et i2 < f in) Faire 4. Si (T [i1 ] < T [i2 ]) 5. temp[i] = T [i1 ] ; 6. i1 = i1 + 1 ; 7. Sinon 8. temp[i] = T [i2 ] ; 9. i2 = i2 + 1 ; 10. Fin Si 11. i = i + 1; 12. Fin Tant que 13. Si (i1 < mid) 14. Pour (j = i1 a mid) Faire 15. temp[i] = T [j ] ; 16. i = i + 1; 17. Fin Pour 18. Sinon Si (i2 < f in) 19. Pour (j = i2 a f in) Faire 20. temp[i] = T [j ] ; 21. i = i + 1; 22. Fin Pour 23. Fin Si 24. Pour (i = deb a f in) Faire 25. T [i] = temp[i] ; 26. Fin Pour

Lalgorithme r ecursif de tri par fusion est le suivant :

Algorithme triFusion (T , deb, f in) 1. Si (deb < f in) 2. mid = (deb + f in)/2 ; 3. triFusion (T , deb, mid) ; 4. triFusion (T , mid + 1, f in) ; 5. fusion (T , deb, f in) ; 6. Fin Si

La complexit e de cet algorithme est en O(n log2 (n)). Structure de donn ee : Pour etre ecace du point de vue du temps, la proc edure de fusion n ecessite un tableau interm ediaire : plus grande complexit e en m emoire. 8

Ce nest pas le cas si les donn ees sont repr esent ees par des listes cha n ees. Dans ce cas, aucune liste interm ediaire nest n ecessaire, et la complexit e en temps du tri par fusion est toujours en O(n log2 (n)).

R esum e

Les m ethodes de tri peuvent etre subdivis ees en quatre classes principales : le tri par insertion, le tri par s election (tri par s ection direct ou tri par monceaux), le tri par echange (tri ` a bulles ou Quicksort), et le tri externe. Le choix dune m ethode de tri d epend de plusieurs crit` eres : La taille de la liste ` a trier. Si la liste est courte, la m ethode la plus simple ` a programmer (tri par insertion ou tri par s election direct) est probablement la plus ecace dun point de vue pratique. Si la liste est trop longue pour quune recherche en O(n2 ) soit ecace, mais assez courte pour etre stock ee en m emoire interne, alors on peut choisir Quicksort ou le tri par fusion. Si la liste est repr esent ee par un tableau, on peut utiliser le tri par insertion, le tri par s election, ou le tri par echange. Si la liste est repr esent ee par une liste cha n ee, on peut utiliser le tri par insertion ou le tri par fusion.