57 lines
2.4 KiB
Java
57 lines
2.4 KiB
Java
public class ExoUnExam {
|
|
|
|
public <T> T deplacerSaufMin(Deque<T> source, Deque<T> destination, Comparator<T> comparateur) {
|
|
if (source.isEmpty()) {
|
|
return null;
|
|
}
|
|
|
|
T min = source.removeFirst(); // 1. On prend le premier élément comme min provisoire
|
|
while (!source.isEmpty()) { // 2. On parcourt le reste de la pile
|
|
T candidat = source.removeFirst();
|
|
|
|
// Si candidat est plus petit que min
|
|
if (comparateur.compare(candidat, min) < 0) {
|
|
// L'ancien min n'était pas le bon, on le déplace vers la destination
|
|
destination.addFirst(min);
|
|
// On met à jour le min
|
|
min = candidat;
|
|
} else {
|
|
// Le candidat n'est pas le min, on le déplace
|
|
destination.addFirst(candidat);
|
|
}
|
|
}
|
|
// 3. On retourne le minimum trouvé (il n'est pas dans la destination)
|
|
return min;
|
|
}
|
|
|
|
public <T> void trier(Deque<T> pile, Comparator<T> c) {
|
|
// Pile pour construire le résultat trié
|
|
Deque<T> pileTriee = new LinkedList<>();
|
|
// Pile temporaire pour stocker les éléments non-min
|
|
Deque<T> temp = new LinkedList<>();
|
|
|
|
while (!pile.isEmpty()) {
|
|
// 1. On extrait le min de 'pile', le reste va dans 'temp'
|
|
T min = deplacerSaufMin(pile, temp, c);
|
|
|
|
// 2. On place le min dans notre pile finale (ici on empile, donc le plus petit sera au fond si on continue...
|
|
// ATTENTION : Pour avoir le plus petit au SOMMET à la fin, il faudrait trouver le MAX d'abord.
|
|
// Mais le sujet impose le tri par sélection du MINIMUM.
|
|
// Donc on empile les minimums successifs : min1, min2...
|
|
// La pileTriee aura min1 au fond, min2 au dessus... minMax au sommet. C'est un tri décroissant au dépilement.
|
|
// Si on veut croissant au dépilement, il faudrait une autre logique, mais suivons la consigne stricte).
|
|
pileTriee.addFirst(min);
|
|
|
|
// 3. On remet tout de temp vers pile pour recommencer
|
|
while(!temp.isEmpty()) {
|
|
pile.addFirst(temp.removeFirst());
|
|
}
|
|
}
|
|
|
|
// 4. On remet tout dans la pile d'origine comme demandé ("la pile triée finale devra être la pile donnée en argument")
|
|
// Si pileTriee a [5, 4, 3, 2, 1] (1 au fond), en renversant on aura [1, 2, 3, 4, 5].
|
|
while(!pileTriee.isEmpty()) {
|
|
pile.addFirst(pileTriee.removeFirst());
|
|
}
|
|
}
|
|
} |