IFT2810 Automne 2008

Avantages du tri par insertion : Mthode naturelle, facile a programmer. De plus, la e ` mthode est dautant plus rapide que la liste a trie est presque ordonne : la mthode est e ` e e e plus ecace pour une liste presque trie que pour une liste dans un ordre alatoire. e e Structure de donnes : Mthode aussi ecace si la liste ` trie est reprsente par un e e a e e e tableau ou par une liste cha ee. n

Algorithmes de tri

Le tri dun ensemble de donnes est lune des taches les plus courantes en informatique. e Il existe plusieurs algorithmes connus de tri. Certains ont une complexit en O(n2 ). Le plus e ecace (quick sort) a une complexit en O(n log2 (n)). Ces algorithmes peuvent tre utiliss, e e e soit pour trier des lments en ordre croissant, soit en ordre dcroissant. Si lordre nest pas ee e spci, alors lordre croissant est considr par dfaut. e e ee e

Tri par slection e

Tri par insertion

` Cest lun des algorithmes les plus utiliss pour le tri. Imaginez une main de carte. A e chaque fois que le joueur prend une nouvelle carte, il lintroduit dans sa main de telle sorte quelle reste ordonne. Le tri par insertion est bas sur cette ide dinsertion dans une liste e e e ordonne. e La liste ` trier est divise en deux : la partie gauche est trie, et la partie droite est a e e non-trie. A chaque passage, le premier lment de la partie non-trie est introduite dans la e ` ee e partie trie, de telle sorte que cette derni`re reste trie. Pour une liste de n lments, n 1 e e e ee passages sont ncessaires. La complexit de lalgorithme est donc en O(n2 ). e e Dans lalgorithme suivant, on consid`re que les indices dun tableau commencent ` 0, i.e. e a le premier lment de la liste est ` lindice 0. dernier est lindice du dernier lment du ee a ee 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

Un dsavantage du tri par insertion est que, mme si une liste est presque trie, lintroe e e duction dun nouvel lment dans cette liste peut ncessiter le mouvement de la plupart des ee e lments de la liste. Si la liste a trier est tr`s grande, ce mouvement de tous les lments ` ee ` e ee a chaque introduction dun nouvel lment dans la liste peut tre tr`s coteux. Il serait souee e e u haitable de pouvoir immdiatement placer un lment ` sa place nale. Cest lavantage du e ee a tri par slection. e La liste ` trier est divise en deux : la partie gauche est trie, et la partie droite est a e e non-trie. De plus, tous les lments de la partie gauche sont plus petits (ou gaux) que les e ee e ` lments de la partie droite. A chaque passage, llment minimal de la partie non-trie est ee ee e chang avec la premier lment de la liste non-trie. Ainsi, la liste trie cro de 1 lment. e e ee e e t ee Pour une liste de n lments, n 1 passages sont ncessaires. La complexit de lalgorithme ee e e 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 donnes : La mthode est approprie si la liste est reprsente par un e e e e e tableau. Pas approprie si la liste est reprsente par une liste cha ee. e e e n

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

3
3.1

Tri par change e

Tri ` bulles a
75 70 65 84 98 78 100 93 55 61 81 68 ` On veut placer le pivt (75) a sa place nale dans la liste. A cette tape tout ce quon o ` e veut cest avoir les lments plus petit que le pivt avant le pivt, et les lments plus grands ee o o ee apr`s. On eectue les tapes suivantes : e e On parcourt la liste de gauche a droite a partir du pivt a lindice l, et on sarrte d`s ` ` o ` e e quon arrive a un indice i contenant une valeur plus grande que le pivt ; ` o 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 sarrte d`s quon arrive a un indice j ` e e ` contenant une valeur plus petite que le pivt ; o 75 |l 70 65 84 98 78 100 93 55 61 81 68|j |r On change les valeurs aux indices i et j. Les deux parties du tableau, de 1 a i, et de e ` j ` r sont correctes : i.e. tous les lments de la 1`re partie sont plus petits que le a ee e pivt, et tous les lments de la deuxi`me partie sont plus grands que le pivt. o ee e o 75 70 65 68 |l 98 78 100 93 55 61 81 |r 84 On refait la mme chose dans le sous-tableau [l + 1..r 1]. e 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 mme place ou se croisent, ` e il ne reste plus qu` placer le pivt a la bonne place par un simple change. a o ` e 55 70 65 68 61 75 100 93 78 98 81 84 Knuth a montr que cette procdure est ecace pour des listes susemment longues. e e Lorsque les listes a trier sont courtes (moins que 16 lments), il est plus ecace dutiliser ` ee le simple tri par insertion. Cependant, il faut gnraliser ce dernier algorithme pour trier un e e sous-tableau quelconque, ne commenant pas forcment ` lindice 0. La gnralisation est c e a e e dcrite ci-dessous. e 4

La liste ` trier est divise en deux : la partie gauche est trie, et la partie droite est a e e ` non-trie. On eectue au plus n 1 passages. A chaque passage, llment minimal de la e ee partie non-trie se retrouve chang avec la premier lment de la liste non-trie. Ainsi, la e e e ee e liste trie cro de 1 lment. La dirence entre le tri ` bulles et le tri par slection, est e t ee e a e que le tri a bulle compare chaque paire (u,v) de cases conscutives du tableau non tri en ` e e ` commenant par la n du tableau. A chaque fois que u > v, u et v sont changs. De ce c e e fait, a la n dun passage, on est sr que le plus petit lment de la partie non-trie sera au ` u ee e dbut de cette partie. Le fait de comparer chaque paire de cases conscutives permet de faire e e moins de passages que le tri par slection : si au cours dun passage aucun change na t e e ee eectu, alors la liste est trie et on sarrte. La complexit dans le pire des cas est toujours e e e e 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 change plus ecace que le tri a bulles. Le probl`me de ce dernier est e ` e quil faut un grand nombre dchanges pour placer un lment ` la bonne place. Quicksort e ee a ncessite moins dchanges. e e ` A chaque tape, lalgorithme slectionne un lment particulier du tableau : le pivt. Le e e ee o tableau est alors divis en trois parties : les lments plus petits que le pivt, le pivt, et les e ee o o lments plus grands que le pivt. Autrement dit, le pivt est plac ` sa bonne position. On ee o o ea recommence ensuite, rcursivement, pour la partie gauche et la partie droite du tableau. e On pourrait prendre comme lment pivt le premier, le dernier, ou tout autre lment ee o ee du tableau, et ensuite le placer ` la bonne position. En gnral cest llment du milieu qui a e e ee est slectionn, et permut avec les lments de dbut et de n. e e e ee e Ici on suppose, par simplicit, que le pivt est le premier lment de la liste. Pour illustrer e o ee la mthode, considrons la liste : e e 3

Algorithme quickInsertion (liste <Tableau>, premier <entier>, dernier <entier>) premier et dernier sont les deux indices dnissants le sous-tableau de liste ` trier e a
1. 2. 3. 4. 5. 6. 7. 8. 9.

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

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 lments pour dcrire lalgorithme Quicksort rcursif. ee e e

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 proportionnelle a la taille du tableau e ` a ` trier. Si le pivot est bien choisit (situ ` peu pr`s au milieu du tableau), la taille du tableau ea e est divise par deux a chaque tape. La complexit moyenne de lalgorithme est donc en e ` e e O(n log2 n). Par contre, la complexit dans le pire des cas est en O(n2 ). e Choix du pivt : Le choix du premier lment comme pivt est correct si on a aaire a o ee o ` une liste alatoire. Si la liste est presque trie ou presque trie dans le sens inverse, alors e e e un meilleur choix est de prendre llment du milieu. ee

Tri par fusion

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

Cest une autre mthode diviser pour reigner. Comme pour Quicksort, la liste a trier e ` est subdivise en deux parties. Chaque partie est trie sparment, et ensuite fusionne. e e e e e 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 procdure rcursive du tri par fusion est dcrite ci-dessous : e e e triFusion(tableau) Si tableau a au moins deux lments ee subdiviser le tableau en deux sous-tableaux T1 , T2 ; triFusion(T1 ) ; triFusion(T2 ) ; fusion(T1 , T2 ) ; La fusion de deux sous-tableaux tris se fait de telle sorte que le tableau rsultat soit tri. e e e e Dans lalgorithme suivant, les deux tableaux a fusionner sont T1 et T2 , et le tableau rsultat ` est T . n1 , n2 sont respectivement le nombre dlments de T1 et T2 . ee
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

Lalgorithme rcursif de tri par fusion est le suivant : e

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 de cet algorithme est en O(n log2 (n)). e Plutt que de passer trois tableaux en param`tres de fusion, il sut de passer le tableau o e initial, et deux indices indiquant le dbut et la n du sous-tableau a trier. On a quand mme e ` e besoin, dans ce cas, dun tableau intermdiaire, dclar comme variable locale. e e e Structure de donne : Pour tre ecace du point de vue du temps, la procdure de e e e fusion ncessite un tableau intermdiaire : plus grande complexit en mmoire. e e e e 8

Ce nest pas le cas si les donnes sont reprsentes par des listes cha ees. Dans ce cas, e e e n aucune liste intermdiaire nest ncessaire, et la complexit en temps du tri par fusion est e e e toujours en O(n log2 (n)).

Rsum e e

Les mthodes de tri peuvent tre subdivises en quatre classes principales : le tri par e e e insertion, le tri par slection (tri par sction direct ou tri par monceaux), le tri par change e e e (tri a bulles ou Quicksort), et le tri externe. ` Le choix dune mthode de tri dpend de plusieurs crit`res : e e e La taille de la liste a trier. Si la liste est courte, la mthode la plus simple a programmer ` e ` (tri par insertion ou tri par slection direct) est probablement la plus ecace dun point e de vue pratique. Si la liste est trop longue pour quune recherche en O(n2 ) soit ecace, mais assez courte pour tre stocke en mmoire interne, alors on peut choisir Quicksort ou le tri e e e par fusion. Si la liste est reprsente par un tableau, on peut utiliser le tri par insertion, le tri par e e slection, ou le tri par change. e e Si la liste est reprsente par une liste cha ee, on peut utiliser le tri par insertion ou e e n le tri par fusion.