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