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

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] ;


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();



{ arr03[i] = (n1-i); }

System.out.println(" *** expérimentation sur des données d''entrées trié à l''envers ***");


sorting.selectionSort(arr03);


System.out.println();



{ arr02[i] =(int)(Math.random()*128); }

System.out.println(" *** expérimentation sur des données d''entrées aléatoire ***");


sorting.selectionSort(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.

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

Data & Analytics

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