fin arbre

DEV3.2/Files/chaine/Arithmetique.java

@@ -1,58 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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/chaine/LinkedQueue.java

@@ -0,0 +1,79 @@
+import java.util.AbstractQueue;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class LinkedQueue<E> extends AbstractQueue<E> {
+
+    private Node<E> head; // Tête de la file
+    private Node<E> tail; // Fin de la file
+    private int size;     // Taille de la file
+
+    public LinkedQueue() {
+        head = null;
+        tail = null;
+        size = 0;
+    }
+
+    @Override
+    public boolean offer(E e) {
+        if (e == null) {
+            throw new NullPointerException("Les éléments null ne sont pas autorisés.");
+        }
+        Node<E> newNode = new Node<>(e);
+        if (tail == null) { // File vide
+            head = newNode;
+            tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+        return true;
+    }
+
+    @Override
+    public E poll() {
+        if (head == null) { // File vide
+            return null;
+        }
+        E element = head.element;
+        head = head.next;
+        if (head == null) { // La file est maintenant vide
+            tail = null;
+        }
+        size--;
+        return element;
+    }
+
+    @Override
+    public E peek() {
+        return (head == null) ? null : head.element;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<E>() {
+            private Node<E> current = head;
+
+            @Override
+            public boolean hasNext() {
+                return current != null;
+            }
+
+            @Override
+            public E next() {
+                if (current == null) {
+                    throw new NoSuchElementException();
+                }
+                E element = current.element;
+                current = current.next;
+                return element;
+            }
+        };
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}

DEV3.2/Files/chaine/MergeSortQueue.java

@@ -0,0 +1,76 @@
+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 LinkedQueue<>();
+        Queue<T> file2 = new LinkedQueue<>();
+        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.offer(source.poll());
+        }
+        while (!source.isEmpty()) {
+            file2.offer(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 LinkedQueue<>();
+
+        while (!file1.isEmpty() && !file2.isEmpty()) {
+            if (file1.peek().compareTo(file2.peek()) <= 0) {
+                resultat.offer(file1.poll());
+            } else {
+                resultat.offer(file2.poll());
+            }
+        }
+
+        // Ajouter les éléments restants de chaque file, s'il en reste
+        while (!file1.isEmpty()) {
+            resultat.offer(file1.poll());
+        }
+        while (!file2.isEmpty()) {
+            resultat.offer(file2.poll());
+        }
+
+        return resultat;
+    }
+
+    // Méthode de test pour le tri
+    public static void main(String[] args) {
+        Queue<Double> file = new LinkedQueue<>();
+
+        // Remplir la file avec les arguments passés en ligne de commande
+        for (String arg : args) {
+            file.offer(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/Node.java

@@ -0,0 +1,9 @@
+// Classe interne pour représenter un nœud
+    public class Node<E> {
+        E element;
+        Node<E> next;
+
+        Node(E element) {
+            this.element = element;
+        }
+    }

DEV3.2/Files/tableau/Arithmetique.java

@@ -1,56 +0,0 @@
-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/ArrayQueue.java

@@ -0,0 +1,93 @@
+import java.util.AbstractQueue;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class ArrayQueue<E> extends AbstractQueue<E> {
+
+    private static final int INITIAL_CAPACITY = 10; // Taille initiale du tableau
+    private E[] elements; // Tableau contenant les éléments
+    private int head;     // Index de la tête de la file
+    private int tail;     // Index de la queue de la file
+    private int size;     // Nombre d'éléments dans la file
+
+    @SuppressWarnings("unchecked")
+    public ArrayQueue() {
+        elements = (E[]) new Object[INITIAL_CAPACITY];
+        head = 0;
+        tail = 0;
+        size = 0;
+    }
+
+    @Override
+    public boolean offer(E e) {
+        if (e == null) {
+            throw new NullPointerException("Les éléments null ne sont pas autorisés.");
+        }
+        if (size == elements.length) {
+            redimensionner();
+        }
+        elements[tail] = e;
+        tail = (tail + 1) % elements.length;
+        size++;
+        return true;
+    }
+
+    @Override
+    public E poll() {
+        if (size == 0) {
+            return null;
+        }
+        E element = elements[head];
+        elements[head] = null; // Libération de la référence pour éviter les fuites mémoire
+        head = (head + 1) % elements.length;
+        size--;
+        return element;
+    }
+
+    @Override
+    public E peek() {
+        return (size == 0) ? null : elements[head];
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<E>() {
+            private int index = head;
+            private int remaining = size;
+
+            @Override
+            public boolean hasNext() {
+                return remaining > 0;
+            }
+
+            @Override
+            public E next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                E element = elements[index];
+                index = (index + 1) % elements.length;
+                remaining--;
+                return element;
+            }
+        };
+    }
+
+    // Méthode privée pour redimensionner le tableau lorsqu'il est plein
+    @SuppressWarnings("unchecked")
+    private void redimensionner() {
+        int newCapacity = elements.length * 2;
+        E[] newElements = (E[]) new Object[newCapacity];
+        for (int i = 0; i < size; i++) {
+            newElements[i] = elements[(head + i) % elements.length];
+        }
+        elements = newElements;
+        head = 0;
+        tail = size;
+    }
+}

DEV3.2/Files/tableau/File.java

@@ -1,6 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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;
-    }
-}

DEV3.2/Files/tableau/MergeSortQueue.java

@@ -0,0 +1,76 @@
+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 ArrayQueue<>();
+        Queue<T> file2 = new ArrayQueue<>();
+        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.offer(source.poll());
+        }
+        while (!source.isEmpty()) {
+            file2.offer(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 ArrayQueue<>();
+
+        while (!file1.isEmpty() && !file2.isEmpty()) {
+            if (file1.peek().compareTo(file2.peek()) <= 0) {
+                resultat.offer(file1.poll());
+            } else {
+                resultat.offer(file2.poll());
+            }
+        }
+
+        // Ajouter les éléments restants de chaque file, s'il en reste
+        while (!file1.isEmpty()) {
+            resultat.offer(file1.poll());
+        }
+        while (!file2.isEmpty()) {
+            resultat.offer(file2.poll());
+        }
+
+        return resultat;
+    }
+
+    // Méthode de test pour le tri
+    public static void main(String[] args) {
+        Queue<Double> file = new ArrayQueue<>();
+
+        // Remplir la file avec les arguments passés en ligne de commande
+        for (String arg : args) {
+            file.offer(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/arbre/infixe/Infixe.java

@@ -0,0 +1,45 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Infixe {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        Deque<Node> stack = new ArrayDeque<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                    case "-":
+                    case "x":
+                    case "/":
+                        // Création d'un nœud opérateur
+                        Node right = stack.pop();
+                        Node left = stack.pop();
+                        stack.push(new OperatorNode(token.equals("x") ? "*" : token, left, right));
+                        break;
+                    default:
+                        // Création d'un nœud opérande
+                        stack.push(new OperandNode(Integer.parseInt(token)));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                Node result = stack.pop();
+                System.out.println("= " + result.toInfix());
+            } 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/arbre/infixe/Node.java

@@ -0,0 +1,4 @@
+// Classe représentant un nœud de l'arbre de syntaxe
+    public abstract class Node {
+        public abstract String toInfix(); // Convertir en notation préfixe
+    }

DEV3.2/arbre/infixe/OperandNode.java

@@ -0,0 +1,12 @@
+public class OperandNode extends Node {
+        int value;
+
+        OperandNode(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toInfix() {
+            return Integer.toString(value);
+        }
+    }

DEV3.2/arbre/infixe/OperatorNode.java

@@ -0,0 +1,20 @@
+// Nœud opérateur
+    public class OperatorNode extends Node {
+        String operator;
+        Node left, right;
+
+        OperatorNode(String operator, Node left, Node right) {
+            this.operator = operator;
+            this.left = left;
+            this.right = right;
+        }
+
+        @Override
+        public String toInfix() {
+            // On ajoute systématiquement des parenthèses autour de chaque opération
+            if (operator == "*"){
+                return "(" + left.toInfix() + " x " + right.toInfix() + ")";
+            }
+            return "(" + left.toInfix() + " " + operator + " " + right.toInfix() + ")";
+        }
+    }

DEV3.2/arbre/prefixe/Node.java

@@ -0,0 +1,4 @@
+// Classe représentant un nœud de l'arbre de syntaxe
+    public abstract class Node {
+        public abstract String toPrefix(); // Convertir en notation préfixe
+    }

DEV3.2/arbre/prefixe/OperatorNode.java

@@ -0,0 +1,16 @@
+// Nœud opérateur
+    public class OperatorNode extends Node {
+        String operator;
+        Node left, right;
+
+        OperatorNode(String operator, Node left, Node right) {
+            this.operator = operator;
+            this.left = left;
+            this.right = right;
+        }
+
+        @Override
+        public String toPrefix() {
+            return operator + " " + left.toPrefix() + " " + right.toPrefix();
+        }
+    }

DEV3.2/arbre/prefixe/Prefixe.java

@@ -0,0 +1,45 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Prefixe {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        Deque<Node> stack = new ArrayDeque<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                    case "-":
+                    case "x":
+                    case "/":
+                        // Opérateur : créer un nœud opérateur
+                        Node right = stack.pop();
+                        Node left = stack.pop();
+                        stack.push(new OperatorNode(token, left, right));
+                        break;
+                    default:
+                        // Opérande : créer un nœud valeur
+                        stack.push(new ValueNode(Integer.parseInt(token)));
+                        break;
+                }
+            }
+
+            // L'AST final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                Node root = stack.pop();
+                System.out.println("= " + root.toPrefix());
+            } 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/arbre/prefixe/ValueNode.java

@@ -0,0 +1,13 @@
+// Nœud feuille (valeur)
+    public class ValueNode extends Node {
+        int value;
+
+        ValueNode(int value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toPrefix() {
+            return Integer.toString(value);
+        }
+    }

DEV3.2/arbre/repertoire/Noeud.java

@@ -0,0 +1,42 @@
+import java.io.File;
+
+// Classe représentant un nœud de l'arbre
+    public class Noeud {
+        String nom;
+        Noeud[] enfants;
+
+        public Noeud(String nom) {
+            this.nom = nom;
+            this.enfants = new Noeud[0]; // Initialement pas d'enfants
+        }
+
+        public void setEnfants(Noeud[] enfants) {
+            this.enfants = enfants;
+        }
+
+        public void afficher(String prefixe) {
+            System.out.println(prefixe + nom);
+            for (Noeud enfant : enfants) {
+                enfant.afficher(prefixe + "  ");
+            }
+        }
+
+        // Méthode pour construire un arbre à partir d'un répertoire
+        public static Noeud construireArbre(File fichier) {
+            Noeud noeud = new Noeud(fichier.getName());
+            if (fichier.isDirectory()) {
+                File[] contenu = fichier.listFiles();
+                if (contenu != null) {
+                    Noeud[] enfants = new Noeud[contenu.length];
+                    for (int i = 0; i < contenu.length; i++) {
+                        System.out.print(fichier.getName()+":");
+                        System.out.print(contenu[i]);
+                        System.out.println("");
+                        enfants[i] = construireArbre(contenu[i]);
+                    }
+                    noeud.setEnfants(enfants);
+                }
+            }
+            return noeud;
+        }
+    }

DEV3.2/arbre/repertoire/Repertoires.java

@@ -0,0 +1,27 @@
+import java.io.File;
+
+public class Repertoires {
+
+    public static void main(String[] args) {
+        if (args.length != 1) {
+            System.out.println("Usage: java Repertoires <nom_du_répertoire>");
+            return;
+        }
+
+        File racine = new File(args[0]);
+        System.out.println("Chemin fourni : " + racine.getAbsolutePath()); // Débogage
+
+        if (!racine.exists()) {
+            System.out.println("Le répertoire spécifié n'existe pas : " + racine.getAbsolutePath());
+            return;
+        }
+
+        if (!racine.isDirectory()) {
+            System.out.println("Le chemin spécifié n'est pas un répertoire : " + racine.getAbsolutePath());
+            return;
+        }
+
+        Noeud arbre = Noeud.construireArbre(racine);
+        arbre.afficher("");
+    }
+}

DEV3.2/dictionnaire/Traces.java

@@ -0,0 +1,24 @@
+import java.util.Map;
+
+public class Traces {
+    public static void main(String[] args) {
+        // Récupération de toutes les piles d'appels des threads
+        Map<Thread, StackTraceElement[]> allStackTraces = Thread.getAllStackTraces();
+
+        // Parcours des threads et affichage des informations
+        for (Map.Entry<Thread, StackTraceElement[]> entry : allStackTraces.entrySet()) {
+            Thread thread = entry.getKey();
+            StackTraceElement[] stackTrace = entry.getValue();
+
+            // Affichage du nom du thread
+            System.out.println(thread.getName() + " :");
+
+            // Affichage de chaque élément de la pile d'appels
+            for (StackTraceElement element : stackTrace) {
+                System.out.println("  " + element);
+            }
+
+            System.out.println(); // Ligne vide pour séparer les threads
+        }
+    }
+}