République Algérienne Démocratique et PopulaireMinistè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
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
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:
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); }
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));
}
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 : 9comparisons operations : 4950 + exchanges operations : 99comparisons 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
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é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.
tableau représente les résultats des comparaisons :
les comparaison C(n)
Taille(n) trié aléatoire trié à l'enversLg2( n ) Lg2 (C(n))
100 4950 4950 4950 6,643856 12,27321200 19900 19900 19900 7,643856 14,28048300 44850 44850 44850 8,228819 15,45282400 79800 79800 79800 8,643856 16,2841500 124750 124750 124750
8,965784 16,92868
600 179700 179700 1797009,228819 17,45523
700 244650 244650 2446509,451211 17,90036
800 319600 319600 3196009,643856 18,28591
900 404550 404550 4045509,813781 18,62596
1000 499500 499500 4995009,965784 18,93013
Les graphes correspondants :
100
200
300
400
500
600
700
800
900
1000
0
100000
200000
300000
400000
500000
600000
Nbr Comparaisons pàp au Taille (Sélection)
trié
aléat
trié à l'en-vers
0
2
4
6
8
10
12
14
16
18
20
lg comparaison
lg com-parai-son
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 =, b = 2,001180586c = log C(N) – b * log(N), c= -1,014653114C (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
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)
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
Les graphes correspondent (des échanges ) :
1 2 3 4 5 6 7 8 9 100
200
400
600
800
1000
1200Nbr 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
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
Remarque sur les comparaisons & les échanges :Tri de sélection :tri de sélection
Taille comparaison échange100 4950 99
200 19900 199
300 44850 299
400 79800 399
500 124750 499
600 179700 599
1 2 3 4 50
20000
40000
60000
80000
100000
120000
140000
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).
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.
Coup d’oeil sur le tir par Insertion:
100 200 300 400 500 600 700 800 90010000
100000
200000
300000
400000
500000
600000
Nbr Comparaison prp au Taille (Insertion)
trié
aléat
trié à l'en-vers
0
2
4
6
8
10
12
14
16
18
20
lg comparaison
lg com-paraison
Le graphe correspondent au résultats des comparaison du tri d’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 au plus i-1 comparaisons à faire.
•On a donc: la complexité est O(N^2)
Le graphe correspondent au résultats des échanges du tri d’Insertion :
100 200 300 400 500 600 700 800 900 10000
100000
200000
300000
400000
500000
600000
Nbr Echanges prp au Taille (Insertion)
Trié
Aléa-toire
Trié à l'envers
0
2
4
6
8
10
12
14
16
18
20
lg Alé-toire
lg Trié à l'en-vers
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)
Remarque sur les comparaisons & les échanges :Tri d’Insertion :
tri de sélection
Taille comparaison échange100 4950 2198200 19900 9120300 44850 21975400 79800 39572500 124750 65053600 179700 91026
1 2 3 4 5 60
20000
40000
60000
80000
100000
120000
140000
160000
180000
com-paraisons
échanges
- 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 N comparaison et 0 (ou O(1/Cte)N) échanges
ConclusionL’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.