file mais dernier marche pas

DEV3.2/Files/MergeSortQueue.java

@@ -0,0 +1,77 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class MergeSortQueue {
+
+    // Méthode de tri principal qui effectue le tri fusion
+    public static <T extends Comparable<T>> Queue<T> trier(Queue<T> file) {
+        if (file.size() <= 1) {
+            return file;
+        }
+
+        // Séparer la file en deux moitiés
+        Queue<T> file1 = new LinkedList<>();
+        Queue<T> file2 = new LinkedList<>();
+        scinder(file, file1, file2);
+
+        // Tri de chaque moitié de façon récursive
+        file1 = trier(file1);
+        file2 = trier(file2);
+
+        // Fusion des deux moitiés triées
+        return fusionner(file1, file2);
+    }
+
+    // Méthode pour diviser une file en deux moitiés
+    private static <T> void scinder(Queue<T> source, Queue<T> file1, Queue<T> file2) {
+        int taille = source.size();
+        for (int i = 0; i < taille / 2; i++) {
+            file1.add(source.poll());
+        }
+        while (!source.isEmpty()) {
+            file2.add(source.poll());
+        }
+    }
+
+    // Méthode pour fusionner deux files triées en une seule file triée
+    private static <T extends Comparable<T>> Queue<T> fusionner(Queue<T> file1, Queue<T> file2) {
+        Queue<T> resultat = new LinkedList<>();
+
+        while (!file1.isEmpty() && !file2.isEmpty()) {
+            if (file1.peek().compareTo(file2.peek()) <= 0) {
+                resultat.add(file1.poll());
+            } else {
+                resultat.add(file2.poll());
+            }
+        }
+
+        // Ajouter les éléments restants de chaque file, s'il en reste
+        while (!file1.isEmpty()) {
+            resultat.add(file1.poll());
+        }
+        while (!file2.isEmpty()) {
+            resultat.add(file2.poll());
+        }
+
+        return resultat;
+    }
+
+    // Méthode de test pour le tri
+    public static void main(String[] args) {
+        Queue<Double> file = new LinkedList<>();
+
+        // Remplir la file avec les arguments passés en ligne de commande
+        for (String arg : args) {
+            file.add(Double.parseDouble(arg));
+        }
+
+        // Tri de la file
+        Queue<Double> fileTriee = trier(file);
+
+        // Affichage des éléments triés
+        for (Double valeur : fileTriee) {
+            System.out.print(valeur + " ");
+        }
+        System.out.println("");
+    }
+}

DEV3.2/Files/chaine/Arithmetique.java

@@ -0,0 +1,58 @@
+import java.util.Queue;
+
+public class Arithmetique {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        // Utilisation de notre implémentation FileChainee pour la file
+        Queue<Integer> queue = new FileChainee<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        queue.offer(queue.poll() + queue.poll());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = queue.poll();
+                        int a = queue.poll();
+                        queue.offer(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        queue.offer(queue.poll() * queue.poll());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = queue.poll();
+                        a = queue.poll();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        queue.offer(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        queue.offer(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant dans la file
+            if (queue.size() == 1) {
+                System.out.println("= " + queue.poll());
+            } else {
+                System.out.println("Erreur : Expression incorrecte.");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage());
+        }
+    }
+}

DEV3.2/Files/chaine/FileChainee.java

@@ -0,0 +1,78 @@
+import java.util.AbstractQueue;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+
+public class FileChainee<E> extends AbstractQueue<E> implements Queue<E> {
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+        }
+    }
+
+    private Node<E> head; // Premier élément de la file
+    private Node<E> tail; // Dernier élément de la file
+    private int size = 0; // Taille de la file
+
+    @Override
+    public boolean offer(E element) {
+        Node<E> newNode = new Node<>(element);
+        if (head == null) {
+            tail = newNode;
+        } else {
+            newNode.next = head;
+        }
+        head = newNode;
+        size++;
+        return true;
+    }
+
+    @Override
+    public E poll() {
+        if (isEmpty()) {
+            return null;
+        }
+        E data = head.data;
+        head = head.next;
+        if (head == null) {
+            tail = null;
+        }
+        size--;
+        return data;
+    }
+
+    @Override
+    public E peek() {
+        return (head == null) ? null : head.data;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<>() {
+            private Node<E> current = head;
+
+            @Override
+            public boolean hasNext() {
+                return current != null;
+            }
+
+            @Override
+            public E next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                E data = current.data;
+                current = current.next;
+                return data;
+            }
+        };
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}

DEV3.2/Files/tableau/Arithmetique.java

@@ -0,0 +1,56 @@
+public class Arithmetique {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        // Utilisation de l'implémentation FileTableau pour la file
+        File<Integer> queue = new FileTableau<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        queue.ajouter(queue.retirer() + queue.retirer());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = queue.retirer();
+                        int a = queue.retirer();
+                        queue.ajouter(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        queue.ajouter(queue.retirer() * queue.retirer());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = queue.retirer();
+                        a = queue.retirer();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        queue.ajouter(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        queue.ajouter(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant dans la file
+            if (queue.taille() == 1) {
+                System.out.println("= " + queue.retirer());
+            } else {
+                System.out.println("Erreur : Expression incorrecte.");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage());
+        }
+    }
+}

DEV3.2/Files/tableau/File.java

@@ -0,0 +1,6 @@
+public interface File<E> {
+    void ajouter(E element);    // Ajoute un élément en fin de la file
+    E retirer();                // Retire et retourne l'élément en tête de la file
+    int taille();               // Retourne la taille de la file
+    boolean estVide();          // Vérifie si la file est vide
+}

DEV3.2/Files/tableau/FileTableau.java

@@ -0,0 +1,41 @@
+public class FileTableau<E> implements File<E> {
+    private static final int CAPACITE_INITIALE = 20;
+    private E[] elements;
+    private int taille = 0;
+    private int debut = 0;
+    private int fin = 0;
+
+    @SuppressWarnings("unchecked")
+    public FileTableau() {
+        elements = (E[]) new Object[CAPACITE_INITIALE]; // Création du tableau initial
+    }
+
+    @Override
+    public void ajouter(E element) {
+        elements[fin] = element;
+        fin = (fin + 1) % elements.length;
+        taille++;
+    }
+
+    @Override
+    public E retirer() {
+        if (estVide()) {
+            throw new IllegalStateException("La file est vide");
+        }
+        E element = elements[debut];
+        elements[debut] = null; // Supprime la référence pour éviter les fuites de mémoire
+        debut = (debut + 1) % elements.length;
+        taille--;
+        return element;
+    }
+
+    @Override
+    public int taille() {
+        return taille;
+    }
+
+    @Override
+    public boolean estVide() {
+        return taille == 0;
+    }
+}