← (précédent) B.4 correction Prose de M. JOURDAIN
B.6 Correction : Nombres premiers
Accueil S O M M A I R E

B.5 Correction : Tirage par ordre numérique

Mini-projet 3 : Ordre numérique

Le but est d'écrire un programme qui demande à l'utilisateur d'entrer une série de nombres réels. Puis le programme affiche ces nombres par ordre croissant ou décroissant (au choix).
Correction mini-projet 3 : ordre croissant


1.     public class MiniProjet3
2.     {
3.          public static void main(String [] args)
4.          {
5.               System.out.print("Saisissez la quantité de saisies : ");
6.               int t = Lire.entierInt();
7.               System.out.println();
8.                
9.               double [] saisies = new double[t];
10.              
11.              for(int i = 0; i < tab.length - 1; i++)
12.              {
13.                   for(int j = 0; j < tab.length - 1; j++)
14.                   {
15.                        if( tab[j] > tab[j+1] )
16.                        {
17.                             int temp = tab[i];
18.                             tab[i] = tab[i+1];
19.                             tab[i+1] = temp;
20.                        }
21.                   }
22.              }
23.              for(int i = 0; i < tab.length; i++)
24.              {
25.                  System.out.print(tab[i] + " - ");
26.              }
27.         }
28.    }
Il existe plusieurs algorithmes de tri numérique. Par ordre croissant ou par ordre décroissant. Celui que j'ai choisi est basique. D'une logique plutôt simple.

Après compilation puis exécution, vous verrez affiché les valeurs saisies par ordre croissant :

Ordonner les éléments d' un tableau se dit en programmation, trier un tableau.
Pour comprendre ce programme, considérez d' abord les lignes de 15 à 20. Je dis que si l' on parcours le tableau du premier élément à l ' avant dernier , si 2 éléments consécutifs sont tels que la valeur du précédent est supérieure à celui du suivant (ligne 15), alors, il faut permuter les valeurs (lignes 17 à 19. je ne vais pas ré-expliquer ça. Déjà fait dans d' autres exemples). C' est ce que tout bon débutant ferait. Et naturellement, à l' affichage, ce ne serait pas forcément suffisant. En effet, Faire seulement ça permet tout au plus de s' assurer que le plus grand élément se trouve en fin de tableau. Voyons un exmple concret :

tableau ayant 5 entiers dans cet ordre : 5, 3, 1, 4, 2

Si j' applique le principe des lignes 15 à 20, j' aurais ceci :

Pour j = 0 : tab[0] > tab[1]. En effet, 5 > 3. Donc je permute et j' ai alors :
3, 5, 1, 4, 2

Pour j = 1 : tab[1] > tab[2]. En effet, 5 > 1. Donc je permute et j' ai alors :
3, 1, 5, 4, 2

Pour j = 2 : tab[2] > tab[3]. En effet, 5 > 4. Donc je permute et j' ai alors :
3, 1, 4, 5, 2

Pour j = 3 : tab[3] > tab[4]. En effet, 5 > 2. Donc je permute et j' ai alors :
3, 1, 4, 2, 5

Comme vous pouvez le constatez, le tableau n' est pas complètement trié par ordre croissant. La seule chose dont on soit sûr, c'est que le 2ème élément soit dans la bonne position. C'est à dire, en dernière position. Il faut refaire tout ceci. Mais cela permet seulement de s' assurer que le deuxième plus grand élément se trouve aussi à la bonne position. Ainsi de suite. Jusqu' à quand ?

1 fois, le 5ème en bonne position
2 fois, le 4ème aussi en bonne position
3 fois, le 3ème aussi en bonne position
4 fois, le 2ème aussien bonne position
Et si les 4 éléments se trouvent en bonne position, forcément le 5ème aussi. Donc, il faut effectuer la boucle (lignes 15 à 20), 4 fois. D' où la première boucle (lignes 11 à 22) dans laquelle se trouve la 2ème boucle..

Dans notre exemple de tableau à 5 éléments, on boucle 4 fois pour permuter les valeurs et on répète 4 fois, les instruction de la boucle de permutation.

Donc, dans notre correction du mini-projet, les 2 boucles se font aussi à la taille du tableau moins 1.
Ci-dessus, la correction du mini-projet 3. Mais cette fois, l'ordre est décroissant.

C'est le même programme que dans l'ordre croissant. Une seule chose à changé. Essayez de le deviner sans regarder.
Correction mini-projet 3bis : ordre croissant


1.     public class MiniProjet3
2.     {
3.          public static void main(String [] args)
4.          {
5.               System.out.print("Saisissez la quantité de saisies : ");
6.               int t = Lire.entierInt();
7.               System.out.println();
8.                
9.               double [] saisies = new double[t];
10.              
11.              for(int i = 0; i < tab.length - 1; i++)
12.              {
13.                   for(int j = 0; j < tab.length - 1; j++)
14.                   {
15.                        if( tab[j] < tab[j+1] )
16.                        {
17.                             int temp = tab[i];
18.                             tab[i] = tab[i+1];
19.                             tab[i+1] = temp;
20.                        }
21.                   }
22.              }
23.              for(int i = 0; i < tab.length; i++)
24.              {
25.                  System.out.print(tab[i] + " - ");
26.              }
27.         }
28.    }
La connaissance, c'est bien. La partager, c'est mieux
Conseiller ce site à un(e) ami(e):

Son e-mail est :       
Une suggestion à faire pour ce site ? ... Contact : webmaster@debutantprog.com
← (précédent) B.4 correction Prose de M. JOURDAIN
B.6 Correction : Nombres premiers
Accueil S O M M A I R E

B.5 Correction : Tirage par ordre numérique