TP n°9 - Thread

Département Informatique
IQ-S2 – M2103 – Bases de la programmation orientée objet

Rendre à l’enseignant, par mail au format PDF, un compte-rendu du TP.

Le but de ce TP est de réaliser une application qui va exécuter trois algorithmes de tri, dans 3
threads différents. Pour se rendre compte de l'état des algorithmes, on effectuera un
affichage graphique ressemblant à la capture suivante (effectuée pendant le tri).

Algorithmes de tris.
Il existe plusieurs algorithmes de tris. Les trois plus classiques sont les suivants.

Le tri bulle (bubble sort)

Le tri à bulles ou tri par propagation est un algorithme de tri qui consiste à faire remonter
progressivement les plus grands éléments d'un tableau, comme les bulles d'air remontent à
la surface d'un liquide.

procédure tri_bulle(tableau T, entier n)

répéter
aucun_échange = vrai
pour j de 0 à n - 2
si T[j] > T[j + 1], alors
échanger T[j] et T[j + 1]
aucun_échange = faux
tant que aucun_échange = faux

Sylvain Rampacek Page 1

TP n°9 - Thread
Département Informatique
IQ-S2 – M2103 – Bases de la programmation orientée objet

1) Créez une classe TSort comportant :

a. Un attribut (privé), nommé tab de type ArrayList<Integer>
b. Un constructeur initialisant l’attribut tab avec un objet tab passé en
paramètre.
c. Une méthode (protégée) swap(int i, int j) permettant d’échanger les éléments
i et j du tableau tab.
d. Une méthode (protégée) getTabCase(int index) permettant de retourner la i-
ème case du tableau tab.
e. Une méthode (protégée) getTabSize() permettant de retourner la taille du
tableau tab.
2) Créez une classe TBubbleSort héritant de la classe TSort. Ajoutez le constructeur.
3) Ajoutez une méthode sort() implémentant l’algorithme décrit ci-dessus.
4) Dans une fonction main() :
a. créez un tableau contenant 20 nombres aléatoires ( (int)(Math.random()*100)
permet de retourner des nombres aléatoires entre 0 et 100)
b. affichez ce tableau
c. instancier un objet de type TBubbleSort et appeler la méthode sort de cet
objet.
d. Affichez à nouveau le tableau et vérifier votre algorithme.

5) Dans le compte-rendu : faire un copier/coller de la méthode sort, faire un

copier/coller du tableau non trié et trié.

Le tri par sélection (selection sort)

Le tri par sélection (ou tri par extraction) est un algorithme de tri par comparaison. Il est
particulièrement simple, mais inefficace sur de grandes entrées, car il s'exécute en temps
quadratique en le nombre d'éléments à trier.

Sur un tableau de n éléments (numérotés de 0 à n-1), le principe du tri par sélection est le
suivant :
- rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 0 ;
- rechercher le second plus petit élément du tableau, et l'échanger avec l'élément
d'indice 1 ;
- continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.

procédure tri_selection(tableau t, entier n)

pour i de 0 à n - 2
min <- i

Sylvain Rampacek Page 2

TP n°9 - Thread
Département Informatique
IQ-S2 – M2103 – Bases de la programmation orientée objet

pour j de i+1 à n
si t[j] < t[min], alors min <- j
si min ≠ i, alors échanger t[i] et t[min]

6) Faire une classe TSelectionSort, héritant de TSort et ayant une méthode sort()
implémentant le tri ci-dessus.
7) Dans le compte-rendu : faire un copier/coller de la méthode sort, faire un
copier/coller du tableau non trié et trié.

Le tri rapide (quick sort)

/!\ : s’il vous reste assez de temps, sinon, passez directement à l’implémentation du thread
et graphique.

Le tri rapide (en anglais quicksort) est un algorithme de tri inventé par C.A.R Hoare en 1961
et fondé sur la méthode de conception diviser pour régner. La complexité moyenne du tri
rapide pour n éléments est proportionnelle à n log n, ce qui est optimal pour un tri par
comparaison, mais la complexité dans le pire des cas est quadratique. Malgré ce désavantage
théorique, c'est en pratique un des tris les plus rapides, et donc un des plus utilisés.

La méthode consiste à placer un élément du tableau (appelé pivot) à sa place définitive, en

permutant tous les éléments de telle sorte que tous ceux qui lui sont inférieurs soient à sa
gauche et que tous ceux qui lui sont supérieurs soient à sa droite. Cette opération s'appelle
le partitionnement. Pour chacun des sous-tableaux, on définit un nouveau pivot et on répète
l'opération de partitionnement. Ce processus est répété récursivement, jusqu'à ce que
l'ensemble des éléments soit trié.

tri_rapide(tableau t, entier premier, entier dernier)

début
si premier < dernier alors
pivot := (premier+dernier) / 2
pivot := partitionner(t,premier,dernier,pivot)
tri_rapide(t,premier,pivot-1)
tri_rapide(t,pivot+1,dernier)
fin si
fin

partitionner(tableau T, premier, dernier, pivot)

échanger T[pivot] et T[dernier]
j := premier
pour i de premier à dernier - 1
si T[i] ≤ T[dernier] alors
échanger T[i] et T[j]
j := j + 1
échanger T[dernier] et T[j]
renvoyer j

Sylvain Rampacek Page 3

TP n°9 - Thread
Département Informatique
IQ-S2 – M2103 – Bases de la programmation orientée objet

8) Faire une classe TQuickSort, héritant de TSort et ayant une méthode sort()
implémentant le tri ci-dessus (tri_rapide et partitionner devenant deux méthodes
privés appelées par sort())..
9) Dans le compte-rendu : faire un copier/coller de la méthode sort, faire un
copier/coller du tableau non trié et trié.

Lancement d'un thread.

(pour (information))
Un thread est un processus léger. Si votre programme comporte 2 threads, il peut faire deux
choses en même temps. Par défaut, un programme comporte un seul thread. L'utilisation de
2 threads permet alors, par exemple, de dessiner et faire un calcul en même temps.
Pour créer un thread, il faut, tout d'abord, faire implémenter l'interface Runnable à la classe
qui devra s'exécuter dans ce nouveau thread. Le « main » de ce nouveau thread sera la
fonction run() de la classe implémentant l'interface Runnable (que l'on va appeler
MonObjetThread).
Ensuite, dans le main, il faudra créer une instance de Thread dont le paramètre du
constructeur est une instance de la classe précédente (exemple : Thread monthread = new
Thread ( new MonObjetThread() ) ; ).
Enfin, l'appel à monthread.start() permettra d'exécuter la fonction « run() » de votre
nouveau thread.

Interface graphique.
1. Remplacer votre classe TSort par celle sur le commun gérant les threads (voir
description ci-dessus). Ajouter un deuxième constructeur à vos classes de tris
(appelant le super avec tous les arguments de la classe mère).

2. Ajouter une nouvelle JFrame Form à votre application.

3. En utilisant le mode « Design » de Netbeans, ajouter 3 « Panels » et 1 bouton comme

le montre la capture ci-dessus (veillez surtout à ce que les 3 panels soient de même
hauteur (300 pixels) et largeur (150 pixels)).

4. Ajouter un événement associé au clic du bouton (clic droit,

Events/Action/ActionPerformed ou double clique directement).

5. Dans la fonction ainsi affichée, il vous faudra :

1. Récupérer la hauteur minimale des 3 « Panels » (utiliser jPanel1.getHeight() et
Math.min(a,b)) (appelée hauteur par la suite).
2. Récupérer la largeur minimale des 3 « Panels » (utiliser jPanel1.getWidth())

Sylvain Rampacek Page 4

TP n°9 - Thread
Département Informatique
IQ-S2 – M2103 – Bases de la programmation orientée objet

(appelée largeur par la suite).

3. Initialiser un « ArrayList<Integer> tab » qui devra être un tableau de (hauteur - 2)
entiers dont les valeurs sont comprises entre 0 et largeur (Math.random() *
largeur)

6. Lancer un thread par tri.

Exemple :
Thread bubblesort =
new Thread (
new TBubbleSort(
(ArrayList<Integer>)tab1.clone(),
jPanel1.getGraphics(),
jPanel1.getWidth(),
jPanel1.getHeight()
)
);
bubblesort.start() ;

Dans le compte-rendu : faire une capture écran de la fenêtre pendant le tri et après le tri.

Sylvain Rampacek Page 5