fin piles

DEV3.2/Piles/chaine/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 notre implémentation PileChainee pour la pile
+        Pile<Integer> stack = new PileChainee<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        stack.push(stack.pop() + stack.pop());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = stack.pop();
+                        int a = stack.pop();
+                        stack.push(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        stack.push(stack.pop() * stack.pop());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = stack.pop();
+                        a = stack.pop();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        stack.push(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        stack.push(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                System.out.println("= " + stack.pop());
+            } 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/Piles/chaine/Pile.java

@@ -0,0 +1,7 @@
+// Interface représentant une pile
+public interface Pile<E> {
+    void push(E element);      // Ajoute un élément en haut de la pile
+    E pop();                   // Retire et retourne l'élément en haut de la pile
+    int size();                // Retourne la taille de la pile
+    boolean isEmpty();         // Vérifie si la pile est vide
+}

DEV3.2/Piles/chaine/PileChainee.java

@@ -0,0 +1,43 @@
+// Classe PileChainee utilisant une liste chaînée pour stocker les éléments
+public class PileChainee<E> implements Pile<E> {
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+        }
+    }
+
+    private Node<E> top;  // Le sommet de la pile
+    private int size = 0; // Taille de la pile
+
+    @Override
+    public void push(E element) {
+        Node<E> newNode = new Node<>(element);
+        newNode.next = top; // Le nouvel élément pointe vers l'ancien sommet
+        top = newNode;      // Le nouvel élément devient le sommet de la pile
+        size++;
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new IllegalStateException("La pile est vide");
+        }
+        E data = top.data; // Récupère la donnée du sommet
+        top = top.next;    // Le sommet devient l'élément suivant
+        size--;
+        return data;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+}