ajout crypto

DEV3.2/ancien_controle/imagine/BullesQueue.java

@@ -0,0 +1,69 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BullesQueue {
+
+    /**
+     * Effectue un parcours (bulle) dans une file.
+     *
+     * @param source      La file source contenant les entiers à trier.
+     * @param destination La file destination pour stocker le résultat du parcours.
+     * @return true si l'ordre des valeurs a changé, false sinon.
+     */
+    public static boolean bulle(Queue<Integer> source, Queue<Integer> destination) {
+        boolean changed = false;
+        if (source.isEmpty()) {
+            return false;
+        }
+
+        int prev = source.poll(); // Récupère le premier élément
+        while (!source.isEmpty()) {
+            int current = source.poll();
+            if (prev > current) { // Si les éléments ne sont pas dans l'ordre croissant
+                changed = true;
+                destination.add(current);
+                prev = prev; // L'ordre change
+            } else {
+                destination.add(prev); // Ajoute directement dans l'ordre
+                prev = current;
+            }
+        }
+        destination.add(prev); // Ajoute le dernier élément
+        return changed;
+    }
+
+    /**
+     * Trie complètement une file d'entiers en utilisant la méthode bulle.
+     *
+     * @param file La file d'entiers à trier.
+     */
+    public static void tri(Queue<Integer> file) {
+        Queue<Integer> intermediaire = new LinkedList<>();
+        boolean changed;
+
+        do {
+            changed = bulle(file, intermediaire); // Effectue un parcours
+            // Inverse les files
+            Queue<Integer> temp = file;
+            file = intermediaire;
+            intermediaire = temp;
+        } while (changed);
+
+        // Affiche les valeurs triées
+        while (!file.isEmpty()) {
+            System.out.print(file.poll() + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        // Exemple d'utilisation avec des entiers passés en ligne de commande
+        Queue<Integer> file = new LinkedList<>();
+        for (String arg : args) {
+            file.add(Integer.parseInt(arg));
+        }
+
+        // Trie la file et affiche le résultat
+        tri(file);
+    }
+}

DEV3.2/ancien_controle/imagine/ExempleQueue.java

@@ -0,0 +1,27 @@
+public class ExempleQueue {
+    public static void main(String[] args) {
+        SimpleQueue<Integer> queue = new SimpleQueue<>();
+
+        // Ajouter des éléments à la file
+        queue.enqueue(10);
+        queue.enqueue(20);
+        queue.enqueue(30);
+
+        // Afficher le premier élément
+        System.out.println("Premier élément : " + queue.peek()); // 10
+
+        // Retirer des éléments
+        System.out.println("Défile : " + queue.dequeue()); // 10
+        System.out.println("Défile : " + queue.dequeue()); // 20
+
+        // Afficher la taille restante
+        System.out.println("Taille de la file : " + queue.size()); // 1
+
+        // Vérifier si la file est vide
+        System.out.println("La file est vide ? " + queue.isEmpty()); // false
+
+        // Retirer le dernier élément
+        System.out.println("Défile : " + queue.dequeue()); // 30
+        System.out.println("La file est vide ? " + queue.isEmpty()); // true
+    }
+}

DEV3.2/ancien_controle/imagine/SimpleQueue.java

@@ -0,0 +1,89 @@
+import java.util.NoSuchElementException;
+
+public class SimpleQueue<T> {
+
+    private static class Node<T> {
+        T value;
+        Node<T> next;
+
+        Node(T value) {
+            this.value = value;
+        }
+    }
+
+    private Node<T> head; // Le début de la file
+    private Node<T> tail; // La fin de la file
+    private int size;
+
+    public SimpleQueue() {
+        head = null;
+        tail = null;
+        size = 0;
+    }
+
+    /**
+     * Ajoute un élément à la fin de la file.
+     *
+     * @param element L'élément à ajouter.
+     */
+    public void enqueue(T element) {
+        Node<T> newNode = new Node<>(element);
+        if (isEmpty()) {
+            head = tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    /**
+     * Retire et renvoie l'élément en tête de la file.
+     *
+     * @return L'élément retiré.
+     * @throws NoSuchElementException si la file est vide.
+     */
+    public T dequeue() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("Queue is empty");
+        }
+        T value = head.value;
+        head = head.next;
+        if (head == null) { // Si la file est désormais vide
+            tail = null;
+        }
+        size--;
+        return value;
+    }
+
+    /**
+     * Renvoie l'élément en tête de la file sans le retirer.
+     *
+     * @return L'élément en tête.
+     * @throws NoSuchElementException si la file est vide.
+     */
+    public T peek() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("Queue is empty");
+        }
+        return head.value;
+    }
+
+    /**
+     * Vérifie si la file est vide.
+     *
+     * @return true si la file est vide, false sinon.
+     */
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * Renvoie le nombre d'éléments dans la file.
+     *
+     * @return La taille de la file.
+     */
+    public int size() {
+        return size;
+    }
+}