Structures de données IFT-2000

Présentation au sujet: "Structures de données IFT-2000"— Transcription de la présentation:

1 Structures de données IFT-2000
Abder Alikacem Semaine 14 Les algorithmes de tri Édition septembre 2009 Département d’informatique et de génie logiciel

2 Plan Définitions et propriétés
Les algorithmes de tri simples et leur complexité Les algorithmes de tri complexes et leur complexité Le tri rapide (QuickSort) Le tri-fusion (MergeSort) Le tri par monceau (HeapSort)

3 Traitement de données triées
Le traitement de données déjà triées est plus rapide. Il faut trier des données à bas coût ! nb de comparaisons nb de déplacements d’éléments espace mémoire requis Besoin : attribut de tri (clé) : <nom,…>, <nom,prénom,...> que l’on peut comparer {<,=,>} (c.-à-d.  ordre total)

4 Critères d'analyse Complexité en temps : 2 critères de base
nombre de comparaisons entre clés nombre de transferts (ou d’échanges) d'éléments Complexité en place mémoire : nécessaire au tri tri sur place (in situ) : en O(1) tri à côté : en O(n) Stabilité conserve l'ordre originel pour éléments de clés égales Progressivité à l'étape k trie les k premiers éléments de la liste Configuration particulière des données : aléatoires, triées, inversées, égales, presque triées

5 Les algorithme de tri Les algorithmes de tri «classiques»:
Tris élémentaires tri insertion; tri sélection; Etc.. Tris dichotomiques tri rapide (Quick Sort); tri fusion; Tris par structure tri par arbre (Tree Sort); tri par monceau (Heap Sort) tri pigeonnier (Pigeon Hole). tri basique … et le Bogo tri

6 Tris simples Algorithme#1 : Tri par insertion (trace en classe) insérer chacun des n éléments à la bonne place dans le tableau créé jusqu’ici 44,55,12,42,94,18,06,67 for (int i=1; i<n; i++ ) { Tmp = Tableau[i]; j=i; while ( (--j>=0) && (Tmp<Tableau[j]) ) Tableau[j+1]=Tableau[j]; Tableau[j+1]=Tmp; }

7 Tris simples Tri shell, Donald Shell Une variante du tri par insertion
Principe du tri shell éliminer les plus grands désordres pour abréger le travail aux étapes suivantes Idée ordonner des séries d'éléments éloignés de h, h prenant de valeurs de plus en plus petites (jusqu'à 1) Exemple (suite déterminée empiriquement) hn = (1093, 384, 121, 40, 13, 4, 1) Hn+1 = 3 hn +1 On a démontré que la complexité dans le pire des cas est O(n3/2 ). Très efficace jusqu'à 5000 éléments

8 Tris simples Tri par sélection (trace en classe): 44,55,12,42,94,18,06,67 Algorithme : remplir les cases de 1 à n avec le minimum des éléments du tableau restant for (int i=0 ; i<n-1 ; i++ ) { //Recherche de l'indice du plus petit element min = i; for (int j=i+1 ; j<n ; j++ ) if ( Tableau[j]<Tableau[min] ) min = j; } //Permutation des elements Tmp = Tableau[i]; Tableau[i] = Tableau[min]; Tableau[min] = Tmp; Stable? ,17,21,5,2,9,2,7

9 Tris simples Tri à bulles (« Bubblesort ») : trace en classe 44,55,12,42,94,18,06,67 Algorithme : remonter les plus petites bulles à la surface, et ce, à chaque itération for (int i=0; i<n-1; i++) for (int j=n-1; j>i; j--) if ( Tableau[j-1]> Tableau[j]) { Tmp = Tableau[j-1]; Tableau[j-1] = Tableau[j]; Tableau[j] = Tmp; }

10 Tris simples Tri à bulles (« Bubblesort »)
Première amélioration Une première amélioration consiste à arrêter le processus s'il n'y a aucun échange dans une passe. Deuxième amélioration : ShakerSort Une deuxième amélioration consiste à alterner le sens des passes. Troisième amélioration Une troisième qui consiste à reprendre au début chaque fois qu’il y a une permutation.

11 Tris complexes Tri rapide (« Quicksort ») Tri des bijoutiers Algorithme choisir un pivot p (élément médian) partager le tableau en 2 : sous-tableau de gauche : éléments ≤ p sous-tableau de droite : éléments > p l’élément entre les 2 le pivot est à sa place définitive appel récursif avec le sous-tableau de gauche appel récursif avec le sous-tableau de droite Partage avec pivot = 3 3 2 4 1 7 6 3 2 1 7 4 6 < 3 ³ 3 7 2 1 3 4 6 Trace en classe: 44,55,12,42,94,18,06,67 Suite du tri TRI TRI 3 1 2 4 6 7

12 Problèmes du « Quicksort »
Algorithme récursif hauteur des appels récursifs meilleur cas : O(log n) pire cas : O(n) Comment faire pour minimiser cette hauteur ? empiler toujours de sous-tableaux de taille optimum Tout dépend du choix du pivot du pire cas : O(n2) au meilleur cas : O(n log n) Comment choisir un bon pivot ?

13 Tri par fusion

14 t1 Trié t2 Trié 1 n 1 m t3 Trié 1 n+m
template <typename T> void triFusion(T t[], int debut, int fin) { if(debut<fin) int milieu=(debut+fin)/2; triFusion(t, debut, milieu); triFusion(t, milieu+1, fin); fusionner(t, debut, milieu, fin); }

15 void fusionner(T t[], int debut, int milieu, int fin)
{ int i1=debut; // indice courant dans t[debut..milieu] int i2=milieu+1; // indice courant dans t[milieu+1..fin] int i3=0; // indice courant dans t3 (tableau auxiliaire) T *t3; // tableau auxiliaire dynamique de longueur fin-debut+1 t3= new T[fin-debut+1]; while((i1<=milieu)&&(i2<=fin)) { if(t[i1]<t[i2]) { t3[i3]=t[i1]; i1++;} else { t3[i3]=t[i2]; i2++; } i3++; } if(i1>milieu) // on a epuisé t[debut..milieu] for(;i2<=fin;i2++,i3++) t3[i3]=t[i2]; else // on a epuisé t[milieu+1..fin] for(;i1<=milieu;i1++,i3++) t3[i3]=t[i1]; // il faut transférer t3 à sa place dans t for(i1=0;i1<i3;i1++) { t[i1+debut]=t3[i1]; } delete [] t3;

16 Tris complexes Tri par arbre (« Heapsort ») : trace en classe 44,55,12,42,94,18,06,67 Algorithme bâtir une structure d’arbre sur place hi  h2i hi  h2i+1 structure appelée « monceau » (« heap ») Un arbre complet tel que pour chaque noeud N dont le parent est P, la clé de P est plus grande que celle de N Normalement implémenté dans un tableau Présent dans la STL Offre les fonctions suivantes: push() top() pop() Voir les exemples fournis en exemple dans la semaine 14

17 Tris complexes 44 55 94 42 67 12 18 06 Tri par arbre (« Heapsort ») 2
3 4 5 6 7 8 1

18 Tris complexes 44 55 94 42 67 12 18 06 Création du monceau 2 3 4 5 6 7

19 Tris complexes 44 55 94 42 67 12 18 06 2 3 4 5 6 7 8 1

20 Tris complexes 44 55 94 67 42 12 18 06 2 3 4 5 6 7 8 1

21 Tris complexes 44 55 94 67 42 12 18 06 2 3 4 5 6 7 8 1

22 Tris complexes 44 55 94 67 42 12 18 06 2 3 4 5 6 7 8 1

23 Tris complexes 44 55 94 67 42 18 12 06 2 3 4 5 6 7 8 1

24 Tris complexes 44 55 94 67 42 18 12 06 2 3 4 5 6 7 8 1

25 Tris complexes 44 94 55 67 42 18 12 06 2 3 4 5 6 7 8 1

26 Tris complexes 44 94 55 67 42 18 12 06 2 3 4 5 6 7 8 1

27 Tris complexes 94 44 55 67 42 18 12 06 2 3 4 5 6 7 8 1

28 Tris complexes 94 67 55 44 42 18 12 06 2 3 4 5 6 7 8 1

29 Tris complexes 94 67 55 44 42 18 12 06 2 3 4 5 6 7 8 1

30 Tris complexes Le tri 94 67 55 44 42 18 12 06 2 3 4 5 6 7 8 1

31 Tris complexes 42 67 55 44 94 18 12 06 2 3 4 5 6 7 8 1

32 Tris complexes 42 67 55 44 94 18 12 06 2 3 4 5 6 7 8 1

33 Tris complexes 42 67 55 44 94 18 12 06 2 3 4 5 6 7 8 1

34 Tris complexes 67 42 55 44 94 18 12 06 2 3 4 5 6 7 8 1

35 Tris complexes 67 55 42 44 94 18 12 06 2 3 4 5 6 7 8 1

36 Tris complexes 67 55 42 44 94 18 12 06 2 3 4 5 6 7 8 1

37 Tris complexes 06 55 42 44 94 18 12 67 2 3 4 5 6 7 8 1

38 Tris complexes 55 06 42 44 94 18 12 67 2 3 4 5 6 7 8 1

39 Tris complexes 55 44 42 06 94 18 12 67 2 3 4 5 6 7 8 1

40 Tris complexes 55 44 42 06 94 18 12 67 2 3 4 5 6 7 8 1

41 Tris complexes 12 44 42 06 94 18 55 67 2 3 4 5 6 7 8 1

42 Tris complexes 44 12 42 06 94 18 55 67 2 3 4 5 6 7 8 1

43 Tris complexes 44 42 12 06 94 18 55 67 2 3 4 5 6 7 8 1

44 Tris complexes 44 42 12 06 94 18 55 67 2 3 4 5 6 7 8 1

45 Tris complexes 12 42 44 06 94 18 55 67 2 3 4 5 6 7 8 1

46 Tris complexes 42 12 44 06 94 18 55 67 2 3 4 5 6 7 8 1

47 Tris complexes 42 12 44 06 94 18 55 67 2 3 4 5 6 7 8 1

48 Tris complexes 06 12 44 42 94 18 55 67 2 3 4 5 6 7 8 1

49 Tris complexes 18 12 44 42 94 06 55 67 2 3 4 5 6 7 8 1

50 Tris complexes 18 12 44 42 94 06 55 67 2 3 4 5 6 7 8 1

51 Tris complexes 06 12 44 42 94 18 55 67 2 3 4 5 6 7 8 1

52 Tris complexes 12 06 44 42 94 18 55 67 2 3 4 5 6 7 8 1

53 Tris complexes 12 06 44 42 94 18 55 67 2 3 4 5 6 7 8 1

54 Tris complexes 06 12 44 42 94 18 55 67 2 3 4 5 6 7 8 1

55 Tris complexes 06 12 44 42 94 18 55 67 2 3 4 5 6 7 8 1

56 Conclusion Autres tris
Si le tableau contient un grand nombre de valeurs similaires: algorithme par comptage ou tri par pigeonnier. Dans la cas où les clefs sont bornées (c'est à dire comprises entre un minimum et un maximum connus à l'avance) et en nombre fini: algorithme de tri basique (tri par bacs). ..et bien sûr le bogo tri!

57 Les tris dans la STL Ils sont présents dans la bibliothèque <algorithm> sort(): Doit garantir un temps moyen dans O(n lg n) Le tri rapide (quicksort) répond à ce critère stable_sort(): Doit garantir O(n lg n) dans le pire cas Peut utiliser de la mémoire supplémentaire Le tri par fusion (mergesort) répond à ce critère partial_sort() Doit permettre le tri partiel Le tri par monceau (heapsort) répond à ce critère

58 Exercices. Analyse Algorithmes
En choisissant l’opération d’affectation comme baromètre, déterminez la fonction f(n) qui exprime le temps de calcul pour l’algorithmes suivant. Déduisez sa complexité dans la notation du O().   i  1 Tant Que i < n début j  1 Tant que j < n j  j + 1 fin i  i + 1 b)

59 Exercices. Analyse Algorithmes
Mêmes questions.. c) i  1 Tant Que i < n début j  1 Tant Que j < i j  j + 1 fin i  i +1

60 Exercices. Analyse Algorithmes
Mêmes questions pour l’algorithme suivant. s  0 i  1 Tant Que i ≤ n début s  s - 1 j  1 Tant Que j ≤ i s  s + 2 j  j+1 fin i  i + 1 d)

61 Exercices. Analyse Algorithmes
Tant Que i <n début i  2*i fin g) h) i  1 Tant Que i ≤ n début j  1 Tant Que j < i j  j*2 fin i  i+1