République Algérienne Démocratique et Populaire
Ministère de l’Enseignement Supérieur et de la Recherche Scientifique
Univ...
Plan
• Introduction au Tri Sélection
• Implémentation de l’algorithme de tri par
sélection
• Expérimentations sur des donn...
L’idée est de trier un tableau en déterminant son
plus petit, son deuxième plus petit, troisième plus petit
…etc. C’est à ...
Implémentation de l’algorithme de tri par sélection :
public class SelectionSortGenerics {
private static void exch(Compar...
Class main:
public static void main(String[] args){
SelectionSortGenerics sorting = new SelectionSortGenerics();
int n1 = ...
Expérimentations sur des données déférentes :
On a exécuté le code sur des tableaux des entiers avec des tailles
déférente...
Exécution sur java:
Représentation et interprétation des résultats :
Il est facile de compter le nombre d'opérations
nécessaires. A chaque ité...
tableau représente les résultats des
comparaisons :
les comparaison C(n)
Taille(n) trié aléatoire trié à l'envers
Lg2( n )...
Les graphes correspondants :
0
100000
200000
300000
400000
500000
600000
Nbr Comparaisons pàp au
Taille (Sélection)
trié
a...
En Calculant :
On remarque « log C(N) » est une droite, son formule est :
log C(N)= b* log(N) + c.
Trouvons b et c:
b =
lo...
Résultat :
-Avec le tri par sélection, le nombre de
comparaisons de clés ne dépendent pas de la
nature du tableau (presque...
Représentation et interprétation des résultats
Pour chaque N taille éléments d’entrées l’algo de tri fait N
opérations d’é...
Les graphes correspondent (des échanges ) :
0
200
400
600
800
1000
1200
1 2 3 4 5 6 7 8 9 10
Nbr Echanges pàp Taille
(Séle...
Résultat :
Aussi pour les échanges, la complexité au pire des cas est
égale à la complexité en moyenne. Puisqu’on fait au ...
Remarque sur les comparaisons & les échanges :
Tri de sélection :
tri de sélection
Taille comparaison échange
100 4950 99
...
Coup d’oeil sur le tir par Insertion:
L’idée est de trier successivement les
premiers éléments du tableau.
A la ième étape...
Coup d’oeil sur le tir par Insertion:
0
100000
200000
300000
400000
500000
600000
Nbr Comparaison prp au
Taille (Insertion...
Résultat :
• Pour insérer le i-ème élément, quel que soit
l’état des entrées (triés, non triées) nous avons
au moins 1 et ...
Le graphe correspondent au résultats des échanges du
tri d’Insertion :
0
100000
200000
300000
400000
500000
600000
100 200...
Résultat :
• la méthode de tri par insertion fait
uniquement des échanges. Tel que;
• On compte i-1 échanges dans le meill...
Remarque sur les comparaisons & les échanges :
Tri d’Insertion :
tri de sélection
Taille comparaison échange
100 4950 2198...
Conclusion
L’algorithme du tri par sélection est simple,
mais peu efficace à cause de sa complexité (
spécialement le coût...
Prochain SlideShare
Chargement dans…5
×

Expérimentation et interprétation des algorithmes de tri élémentaires tp algo n°01

385 vues

Publié le

Expérimentation et interprétation des Algorithmes de tri élémentaires

Conception et Analyse des Algorithmes

Publié dans : Données & analyses
0 commentaire
1 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
385
Sur SlideShare
0
Issues des intégrations
0
Intégrations
5
Actions
Partages
0
Téléchargements
14
Commentaires
0
J’aime
1
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Expérimentation et interprétation des algorithmes de tri élémentaires tp algo n°01

  1. 1. République Algérienne Démocratique et Populaire Ministère de l’Enseignement Supérieur et de la Recherche Scientifique Université de Ghardaïa PAR : Soumia Elyakote HERMA ANNEE UNIVERSITAIRE: 2014/2015 Module : Conception et Analyse des Algorithmes TP N° 01: Enseignant : Slimane BELLAOUAR Expérimentation et interprétation des Algorithmes de tri élémentaires
  2. 2. Plan • Introduction au Tri Sélection • Implémentation de l’algorithme de tri par sélection • Expérimentations sur des données déférentes • Exécution sur java • Représentation et interprétation des résultats • les résultats des comparaisons • Les graphes correspondants • Les Calculs • Les Résultats • Les graphes correspondent des échanges • Remarque sur les comparaisons & les échanges Tri de sélection • Coup d’œil sur le Tri par Insertion
  3. 3. L’idée est de trier un tableau en déterminant son plus petit, son deuxième plus petit, troisième plus petit …etc. C’est à dire trouver la position du plus petit élément dans le tableau et ensuite échanger a[0] et a[i1]. Ensuite, déterminer la position i2 de l’élément avec le plus petit des a[1],………..a[N-1] et échanger a[1] et a[i2]. On continue de cette manière jusqu’à ce que tous les éléments soient dans la position correcte. Le tri par sélection:
  4. 4. Implémentation de l’algorithme de tri par sélection : public class SelectionSortGenerics { private static void exch(Comparable[] a, int i, int j) { Comparable t = a[i]; a[i] = a[j]; a[j] = t; } private static boolean less(Comparable v, Comparable w) { return v.compareTo(w) < 0; } public <Object extends Comparable<Object>>void selectionSort(Object[] a) { int compt_exch= 0; int N = a.length; int compt_if= 0; for (int i = 0; i <N - 1; i++) { // find index of smallest element int smallest = i; for (int j = i + 1; j < N; j++) { compt_if++; if (less(a[j], a[smallest])) smallest = j; } exch(a, i, smallest); // swap smallest to front compt_exch++; } System.out.println("comparisons operations : "+compt_if+" + exchanges operations : "+compt_exch); }
  5. 5. Class main: public static void main(String[] args){ SelectionSortGenerics sorting = new SelectionSortGenerics(); int n1 = 750; Integer[] arr01 = new Integer[n1] ; Integer[] arr01 = new Integer[n1] ; for (Integer i=0; i<n1; i++) { arr01[i] = (i); } System.out.println(" *** expérimentation sur des données d''entrées triées ***"); System.out.println("before sorting tab01 : "+ Arrays.toString(arr01)); sorting.selectionSort (arr01); System.out.println("After sorting tab01 : "+Arrays.toString(arr01)); System.out.println(); Integer[] arr03 = new Integer[n1] ; for (Integer i=0; i<n1; i++) { arr03[i] = (n1-i); } System.out.println(" *** expérimentation sur des données d''entrées trié à l''envers ***"); System.out.println("before sorting tab03 : "+ Arrays.toString(arr03)); sorting.selectionSort(arr03); System.out.println("After sorting tab03 : "+Arrays.toString(arr03)); System.out.println(); Integer[] arr02 = new Integer[n1] ; for (Integer i=0; i<n1; i++) { arr02[i] =(int)(Math.random()*128); } System.out.println(" *** expérimentation sur des données d''entrées aléatoire ***"); System.out.println("before sorting tab02 : "+ Arrays.toString(arr02)); sorting.selectionSort(arr02); System.out.println("After sorting tab02 : "+Arrays.toString(arr02)); }
  6. 6. Expérimentations sur des données déférentes : On a exécuté le code sur des tableaux des entiers avec des tailles déférentes : Algorithmes de tri par sélection : Exemple d’exécution : *** expérimentation sur des données d''entrées aléatoire *** before sorting tab1: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] tab2 : [100, 99, .., , 3, 2, 1] tab3 : [1000, 999, .., 3, 2, 1] comparisons operations : 45 + exchanges operations : 9 comparisons operations : 4950 + exchanges operations : 99 comparisons operations : 499500 + exchanges operations : 999 After sorting tab1 : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] tab2[1, 2, 3, 4, 5.. 98, 99, 100] tab3[1, 2, 3, 4, 5...998,999,1000
  7. 7. Exécution sur java:
  8. 8. Représentation et interprétation des résultats : Il est facile de compter le nombre d'opérations nécessaires. A chaque itération, on démarre à l'élément ai et on le compare successivement à ai+1, ai+2, ..., aN. On fait donc N - i comparaisons. On commence avec i = 1 et on finit avec i = N-1. Donc on fait (N-1) + (N-2) + ··· + 2 + 1 = N(N-1)/2 comparaisons, et N-1 échanges. Le tri par sélection fait donc de l'ordre de N2 comparaisons. Donc , le tri par sélection est en O(N2). Ses nombres de comparaison par rapport aux nombres d'éléments du tableau.
  9. 9. tableau représente les résultats des comparaisons : les comparaison C(n) Taille(n) trié aléatoire trié à l'envers Lg2( n ) Lg2 (C(n)) 100 4950 4950 4950 6,643856 12,27321 200 19900 19900 19900 7,643856 14,28048 300 44850 44850 44850 8,228819 15,45282 400 79800 79800 79800 8,643856 16,2841 500 124750 124750 124750 8,965784 16,92868 600 179700 179700 179700 9,228819 17,45523 700 244650 244650 244650 9,451211 17,90036 800 319600 319600 319600 9,643856 18,28591 900 404550 404550 404550 9,813781 18,62596 1000 499500 499500 499500 9,965784 18,93013
  10. 10. Les graphes correspondants : 0 100000 200000 300000 400000 500000 600000 Nbr Comparaisons pàp au Taille (Sélection) trié aléat trié à l'envers 0 2 4 6 8 10 12 14 16 18 20 6.64385619 7.64385619 8.64385619 9.64385619 lg comparaison lg compara ison
  11. 11. En Calculant : On remarque « log C(N) » est une droite, son formule est : log C(N)= b* log(N) + c. Trouvons b et c: b = log(Cn+i)− log(Cn) log(n+i)− log(n) ,  b = 2,001180586 c = log C(N) – b * log(N),  c= -1,014653114 C (N) = a Nb, où  a = 2c = 0,493116 Hypothèse: C (N) =0.493116* N2.001180586 Le nombre d’opérations de comparaisons estimé pour N=650 est: C(650) = 0.493116* (6502.001180586) = 1888489 (179700<1888489<244650) 600 650 700
  12. 12. Résultat : -Avec le tri par sélection, le nombre de comparaisons de clés ne dépendent pas de la nature du tableau (presque trié, non trié et trié dans l’ordre inverse) • La complexité en nombre de comparaisons pour le tri par sélection est donc : MaxC(N)=MinC (N)=MoyC(N) =N(N-1)/2 = O(N^2)
  13. 13. Représentation et interprétation des résultats Pour chaque N taille éléments d’entrées l’algo de tri fait N opérations d’échanges . tableau représente les résultats des échanges : les échanges E(n) Taille(n) trié aléatoire trié à l'envers 100 99 99 99 200 199 199 199 300 299 299 299 400 399 399 399 500 499 499 499 600 599 599 599 700 699 699 699 800 799 799 799 900 899 899 899 1000 999 999 999
  14. 14. Les graphes correspondent (des échanges ) : 0 200 400 600 800 1000 1200 1 2 3 4 5 6 7 8 9 10 Nbr Echanges pàp Taille (Sélection) des entrées triées des entrées aléatoires des entrées triées a l'envers Evidement ; le graph « E(N) » est une droite, son formule est : E(N)= a(N) + b. Trouvons a et b:  b = 1  a = 0.99 Hypothèse: E (N) = (0.99)(N) + 1 Le nombre d’opérations d’échanges estimé pour N=650 est: E(650) = (0.99)(650) + 1 =643 (599< 643 <699) 600 650 700
  15. 15. Résultat : Aussi pour les échanges, la complexité au pire des cas est égale à la complexité en moyenne. Puisqu’on fait au maximum un seul échange à chaque parcours de la boucle FOR interne de l’algorithme implémenté. Comme on a N éléments dans le tableau. On a donc : MaxE(N)= N-1
  16. 16. Remarque sur les comparaisons & les échanges : Tri de sélection : tri de sélection Taille comparaison échange 100 4950 99 200 19900 199 300 44850 299 400 79800 399 500 124750 499 600 179700 599 0 20000 40000 60000 80000 100000 120000 140000 1 2 3 4 5 6 compara isons échanges En remarquant que le tri par sélection prendre une technique insensible : -une complexité de O(n2) pour les opérations de comparaison et O(n) pour les échanges ; ça ce présente malgré que les données d’entrées soit triées (ou partiellement triées).
  17. 17. Coup d’oeil sur le tir par Insertion: L’idée est de trier successivement les premiers éléments du tableau. A la ième étape on insère le ième élément à son rang parmi les i-1 éléments précédents qui sont déjà triés entre eux. L’algorithme commence par s’exécuter à partir du 2ème élément du tableau.
  18. 18. Coup d’oeil sur le tir par Insertion: 0 100000 200000 300000 400000 500000 600000 Nbr Comparaison prp au Taille (Insertion) trié aléat trié à l'envers 0 2 4 6 8 10 12 14 16 18 20 lg comparaison lg comparai son Le graphe correspondent au résultats des comparaison du tri d’Insertion :
  19. 19. Résultat : • Pour insérer le i-ème élément, quel que soit l’état des entrées (triés, non triées) nous avons au moins 1 et au plus i-1 comparaisons à faire. • On a donc: la complexité est O(N^2)
  20. 20. Le graphe correspondent au résultats des échanges du tri d’Insertion : 0 100000 200000 300000 400000 500000 600000 100 200 300 400 500 600 700 800 900 1000 Nbr Echanges prp au Taille (Insertion) Trié Aléatoire Trié à l'envers 0 2 4 6 8 10 12 14 16 18 20 lg Alétoire lg Trié à l'envers
  21. 21. Résultat : • la méthode de tri par insertion fait uniquement des échanges. Tel que; • On compte i-1 échanges dans le meilleur des cas (le comportement avec le tableau déjà trié). D’où : MinE(N)=0 • Avec un tableau trié dans l’ordre inverse, ce qui, est le pire des cas : • Le nombre de mouvements maximal se calcule graphiquement (comme les calcules de tri sélection) • La complexité du nombre de mouvements maximal est : MoyM(N) = O(N^2)
  22. 22. Remarque sur les comparaisons & les échanges : Tri d’Insertion : tri de sélection Taille comparaison échange 100 4950 2198 200 19900 9120 300 44850 21975 400 79800 39572 500 124750 65053 600 179700 91026 0 20000 40000 60000 80000 100000 120000 140000 160000 180000 1 2 3 4 5 6 compar aisons échang es - Le tri par Insertion suit une méthode (technique de tri) sensible : -une complexité de O(n2) pour les comparaisons et O(n2) comme échanges, (dans le pire des cas), et elle diminue (échanges) selon la taille des données . -si les données d’entrées sont trié (partiellement triée) le tri fait
  23. 23. Conclusion L’algorithme du tri par sélection est simple, mais peu efficace à cause de sa complexité ( spécialement le coût d’opérations des comparaisons (selon le type de clé de comparaison)) bien qu’elle utile par à port au autre méthodes de tri si on traite des données de type et de taille plus important. Egalement, une propriété importante du tri par insertion : est son efficacité est meilleure si le tableau initial possède un certain ordre.

×