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

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. 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. 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. 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. 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. 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. Exécution sur java:

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.