Projet Algorithme avancéesur la comparaisson des deux tris

[
Institut Supérieur d'Informatique et Techniques de Communication
Hammam Sousse
]
Année universitaire : 2013/2014
Projet Algorithme avancée sur la
comparaison des deux tris
Elaborée par : onsmayeh Class : 1MPSWM
Amira Bannour

1
Sommaire
I. Introduction : ....................................................................................................................................... 3
1. Tri a bulle : ...................................................................................................................................... 3
a. Code ............................................................................................................................................ 3
i. Mode algorithme ..................................................................................................................... 3
ii. Mode java............................................................................................................................... 3
b. Principe de tri a bulle : ................................................................................................................ 4
c. Complexité : ................................................................................................................................ 5
2. Tri par sélection .............................................................................................................................. 5
a. Code ............................................................................................................................................ 5
i. Mode algorithme : ........................................................................................................................... 5
ii. Mode java........................................................................................................................................ 5
b. Principe ....................................................................................................................................... 6
c. Complexité : ................................................................................................................................ 6
II. Comparaison entre ces deux tris par rapport ales temps d’exécution : ............................................... 6
1. Code de calcule de temps d’exécution : .............................................................................................. 7
2. Etude théorique : ................................................................................................................................. 7
III. Conclusion .......................................................................................................................................... 8

2
Table et figure
Tableau 1 : tableau de resultat de temps d'exécution ............................................................................... 7
Figure 1 : comparaisson de deux tri ............................................................................................................ 8

3
I. Introduction :
Dans ce rapport on va comparer les deux algorithmes de tri par rapport a leur d’exécution et leur
efficacité dans ce la on va représenter ces deux code et les courbes .
Nous avons prendre deux type d’algorithmes a comparer qui sont tri a bulle et tri a sélection
Nous allons présenter ces deux algorithmes en java et en mode algorithmique
1. Tri a bulle :
Le tri à bulles est un algorithme de tri qui consiste à faire augmenter progressivement les plus grands
éléments d'un tableau
a. Code
i. Mode algorithme
Algorithme Tri a Bulles
Local: i , j , n, temp Î Entiers naturels
Entrée : Tab Î Tableau d'Entiers naturels de 1 à n éléments
Sortie : Tab Î Tableau d'Entiers naturels de 1 à n éléments
Début
Pour i de n jusqu’à 1 faire // recommence une sous-suite (a1, a2, ... , ai)
Pour j de 2 jusqu’à i faire // échange des couples non classés de la sous-suite
Si Tab[ j-1 ] > Tab[ j ] alors // aj-1et aj non ordonnés
Temp ¬ Tab [ j-1 ] ;
Tab [ j-1 ] ¬ Tab[ j ] ;
Tab[ j ] ¬ temp //on échange les positions de aj-1et aj
Fin si
Fin pour
Fin pour
Fin Tri a Bulles
ii. Mode java
import java.io.*;
public class Triabulle extends tableau {
/* Fonction de tri a bulle d'un tableau d'entiers */
public static void triABulle(int [] t) {
/* Definition et initialisation a vrai d'un booleen */
/* pour indiquer qu'une permutation a eu lieu lors d'un */
/* parcours a la recherche de permutations a realiser */
boolean permutation = true;
/* Definition est initialisation de la variable entiere */
/* qui indique l'indice du prochain maximum a envoyer */
/* en bout de tableau par permutations successives */
int limite = t.length-1;
int i;
int val;
/* Tant qu'au moins une permutation a eu lieu au cours */
/* de la passe precedente */
while ( permutation ) {
/* Pour l'instant aucune permutation n'a eu lieu au cours */

4
/* de cette passe */
permutation = false;
/* Parcours de t a la recherche de permutations pour tous */
/* les couples de valeurs d'indice i et i+1 pour i variant */
/* de 0 a limite-1 */
for ( i = 0 ; i < limite ; i++ ) {
/* Si une permutation doit etre realisee */
if ( t[i] > t[i+1] ) {
/* Permutation */
val = t[i];
t[i] = t[i+1];
t[i+1] = val;
/* Le booleen permutation passe a vrai pour indiquer */
/* qu'un moins une permutation a eu lieu au cours */
/* de cette passe */
permutation = true; } }
/* Un nouveau maximum a ete "pousse" a sa place */
/* -> La limite de recherche est decrementee de 1 */
limite--; }
}
/* Fonction principale */
public static void main(String [] args) throws IOException {
int n;
/* Lecture clavier de l'indice de debut de recherche */
System.out.println("Taille du tableau:");
n = Integer.valueOf(flux.readLine()).intValue();
/* Définition et allocation d'un tableau de 10 entiers */
/* tires au sort entre 0 et 5 */
int [] tab = new int[n];
initialisation Tableau(tab,100);
System.out.println("Le tableau contient les valeurs suivantes:");
/* Appel a la fonction d'affichage */
affichage Tableau(tab);
System.out.println();
/* Appel a la fonction de tri a bulle */
triABulle(tab);
System.out.println("Le tableau trie est:");
/* Appel a la fonction d'affichage */
affichageTableau(tab);
// temps d’éxécution
long begin = System.currentTimeMillis();
float t=(float) begin/1000f;
System.out.println("le temps d'exécution est :"+t);
}
}
b. Principe de tri a bulle :
Le principe du tri bulle est de comparer deux a deux les élément i et i+1 successivement d’un tableau et
d’effecteur une permutation si i>i+1.on continue de trier jusqu’à ce qu’il n’y ait plus de permutation