tp sur les ABR

DEV.3.2/TP/TP8-ABR/1.Tri/Tri.java

@@ -0,0 +1,62 @@
+import java.awt.*;
+
+public class Tri {
+
+	private boolean estVide;
+	private double valeur;
+	private Tri filsGauche;
+	private Tri filsDroit;
+
+	public Tri() {
+		this.estVide = true;
+	}
+
+	public Tri(double valeur) {
+		this.estVide = false;
+		this.valeur = valeur;
+	}
+
+	public void ajouter(double valeur) {
+		if(this.estVide) {
+			this.valeur = valeur;
+			this.estVide = false;
+			return;
+		}
+
+		if(valeur < this.valeur) {
+			if(this.filsGauche == null) {
+				this.filsGauche = new Tri();
+			}
+			filsGauche.ajouter(valeur);
+		} else {
+			if(this.filsDroit == null) {
+				this.filsDroit = new Tri();
+			}
+			filsDroit.ajouter(valeur);
+		}
+	}
+
+	public String toString() {
+		String aRenvoyer = "";
+
+		if(this.filsGauche != null) {
+			aRenvoyer += this.filsGauche.toString();
+		}
+		aRenvoyer += this.valeur + " ";
+
+		if(this.filsDroit != null) {
+			aRenvoyer += this.filsDroit.toString();
+		}
+
+		return aRenvoyer;
+	}
+
+	public static void main(String[] args) {
+		Tri racine = new Tri();
+
+		for(String chaine : args) {
+			racine.ajouter(Double.parseDouble(chaine));
+		}
+		System.out.println(racine);
+	}
+}

DEV.3.2/TP/TP8-ABR/2.Authentification/Authentification.java

@@ -0,0 +1,10 @@
+public class Authentification {
+
+	private tr identifiant;
+	private  mdp;
+
+
+	public Authentification() {
+
+	}
+}

DEV.3.2/cours/7.Arbres.md

@@ -0,0 +1,16 @@
+**Principe**
+Ce que en informatique on nomme _arbre_ est une évolution directe du concept de liste chaînée. Il suffit pour cela de permettre à chaque maillon de contenir plusieurs références à d'autres maillons. On interdit cependant les références circulaires pour en simplifier le parcours.
+
+![Image d'un arbre](./Pasted%20image%2020260203092554.png)
+
+Un maillon est nommé _nœud_ dans cette nouvelle structure. L'élément qu'il contient est son _étiquette_.
+
+Par analogie avec les arbres généalogiques, un nœud contenant une référence est appelé _nœud parent_ et le nœud référencé est appelé _nœud enfant_. Par analogie avec les véritables arbres, le nœud de départ est nommé _racine_ et les nœuds sans enfants sont nommés _feuilles_.
+
+Les arbres _homogènes_ contiennent des nœuds d'une seule classe. Les arbres _hétérogènes_ permettent plusieurs classes de nœuds (en Java, par substitution).
+
+Un arbre est _binaire_ si aucun de ses nœuds ne peut avoir plus de deux enfants.
+
+Les différentes façon de lire un arbre : 
+
+![Image des différents algo de recherche](./Pasted%20image%2020260203092621.png)

DEV.3.2/cours/8.Arbres binaires de recherches.md

@@ -0,0 +1,90 @@
+**Principe**
+On prend pour hypothèse que les clés sont ordonnées.
+Un arbre binaire possède la propriété "de recherche" si tous ses nœuds vérifient  les deux propositions suivantes : 
+* l'étiquette de ce nœud est plus grande que les étiquettes de tous les nœuds de son sous-arbre gauche.
+* l'étiquette de ce nœud est plus petite que les étiquettes de tous les nœuds de son sous-arbre droit.
+
+
+Cette forme permet d'obtenir toutes les étiquettes dans l'ordre croissant par un parcours en profondeur infixe, donc elle est équivalente à une liste triée.
+Il est plus facile de maintenir cette propriété lors d'un ajout ou d'une suppression que pour une structure linéaire, car de nombreuses formes sont possibles.
+
+Un **ABR** repose sur une règle de structure stricte : pour chaque nœud, les éléments à gauche sont plus petits et les éléments à droite sont plus grands.
+Sans l'interface [`Comparable`](https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html), l'arbre ne saurait pas comment ranger un objet personnalisé (comme une classe `Etudiant` ou `Produit`), car il ne saurait pas si `Etudiant A` est "avant" `Etudiant B`.
+
+![image d'arbre de recherche](abr%20img.png)
+Une autre application de cette structure est la recherche d'élément. Il suffit de descendre dans l'arbre une seule fois pour savoir si une valeur donnée est présente.
+Le coût de cette recherche est proportionnel à la hauteur de l'arbre.
+
+La hauteur minimum d'un arbre binaire à n nœuds est *log2n* et la hauteur maximum est *n*. On peut *équilibrer* un arbre binaire pour diminuer sa hauteur.
+
+**Dictionnaires**
+Un arbre binaire de recherche peut représenter un dictionnaire. Les étiquettes sont les paires clé-valeur et l'ordre des étiquettes est l'ordre des clés.
+
+Pour faire l'opération *put*, on descend dans l'arbre à la recherche de la clé fournie. Si on trouve la clé, on remplace sa valeur. Si on ne la trouve pas, on ajoute un nœud là où la recherche s'est arrêtée.
+
+Pour faire *get*, on recherche la clé et on a immédiatement notre réponse.
+
+Pour faire *remove*, on recherche la clé.
+* Si le nœud est une feuille, on le retire directement.
+* Si le nœud a un enfant, il est remplacé par celui-ci.
+* Si le nœud a deux enfants, on le remplace par son *successeur directe* (qui est retiré d'abord).
+		Il faut trouver le successeur direct à la racine que l'on souhaite supprimé, en allant une fois à droite puis au plus à gauche possible.
+
+Exemple : 
+```java
+public class ArbreDeRecherche<T extends Comparable<T>> {
+
+    private class Noeud {
+        T valeur;
+        Noeud gauche, droite;
+
+        Noeud(T valeur) {
+            this.valeur = valeur;
+        }
+    }
+
+    private Noeud racine;
+
+    public void remove(T valeur) {
+        racine = supprimerRecursif(racine, valeur);
+    }
+
+    private Noeud supprimerRecursif(Noeud actuel, T valeur) {
+        if (actuel == null) return null;
+
+        int comparaison = valeur.compareTo(actuel.valeur);
+
+        if (comparaison < 0) {
+            // On cherche à gauche
+            actuel.gauche = supprimerRecursif(actuel.gauche, valeur);
+        } else if (comparaison > 0) {
+            // On cherche à droite
+            actuel.droite = supprimerRecursif(actuel.droite, valeur);
+        } else {
+            // ÉLÉMENT TROUVÉ : On applique les 3 cas de suppression
+
+            // Cas 1 & 2 : Pas d'enfant ou un seul enfant
+            if (actuel.gauche == null) return actuel.droite;
+            if (actuel.droite == null) return actuel.gauche;
+
+            // Cas 3 : Deux enfants
+            // 1. Trouver le successeur (le plus petit du sous-arbre droit)
+            actuel.valeur = trouverSuccesseur(actuel.droite);
+
+            // 2. Supprimer le successeur dans le sous-arbre droit
+            actuel.droite = supprimerRecursif(actuel.droite, actuel.valeur);
+        }
+        return actuel;
+    }
+
+    private T trouverSuccesseur(Noeud racine) {
+        T valeurMin = racine.valeur;
+        // On descend au plus profond à gauche avec une boucle while
+        while (racine.gauche != null) {
+            valeurMin = racine.gauche.valeur;
+            racine = racine.gauche;
+        }
+        return valeurMin;
+    }
+}
+```