renommage repertoire cours Arbres temporaire

Temp/ARBRES_BINAIRES.md

@@ -0,0 +1,441 @@
+
+
+## Les arbres binaires
+
+>  Parmi la forêt d'arbres possibles, on s'intéressera essentiellement aux arbres dit binaires.
+> Ceux ci sont principalement utilisés pour les bases de données (indexation), les moteurs de recherche, et les compilateurs.
+
+
+
+### Définition:
+Un arbre **binaire** est un arbre de degré 2 (dont lesnoeuds sont de degré 2 au plus).
+
+Les enfants d'un noeud sont lus de **gauche à droite** et sont appelés **fils gauche** et **fils droit**.
+
+![fig15.png](assets/fig15.png)
+
+### Exercice 1:
+Parmi les arbres du cours précédent, lesquels sont binaires ?
+
+Réponse
+
+### Remarque:
+Les arbres binaires forment une structure de données qui peut se définir de façon récursive.
+
+Un arbre binaire est:
+- soit vide
+- soit composé d'une racine portant une étiquette (clé) et d'une paire d'arbres binaires, appelés sous-arbre gauche et sous-arbre droit.
+
+Les arbres binaires sont utilisés dans de très nombreuses activités informatiques, nous allons étudier et implanter cette structure de données.
+
+## Comment représenter un arbre binaire... à la main...
+
+L'idée est de représenter l'arbre avec un tableau.
+
+[r, a, b] La racine r suivie de ses fils gauche et droit.
+
+![fig16.png](assets/fig16.png)
+
+![fig17.png](assets/fig17.png)
+
+Puis on rajoute dans l'ordre les fils gauche et droit de a, puis ceux de b. 
+
+[r, a, b, c, d, e, f]
+
+### Remarque:
+Chaque noeud se repère par son indice *n* dans la liste, son fils gauche se trouvant alors à l'indice *2n + 1* et son fils droit à l'indice *2n + 2*.
+
+Exemple: **b** est d'indice 2, son fils gauche se trouve alors à l'indice 5 et son fils droit à l'indice 6.
+
+Si un noeud n'a pas de fils, on le précise en mettant *None* à sa place. Notre arbre est alors représenté par le tableau:
+
+[r, a, b, c, d, e, f, None, None, None, None, None, None, None, None]
+
+**Quelle taille doit avoir le tableau ?**
+
+![fig18.png](assets/fig18.png)
+
+Cet arbre est complet (tous les noeuds internes ont deux fils).
+
+Il possède 3 niveaux, sa hauteur ou profondeur est donc de 2. La taille du tableau sera de: $$2^0 + 2^1 + 2^2 + 2^3 = 2^4 -1 = 15$$
+
+*Il faut compter le nombre de noeuds, y compris les noeuds "fantômes" des feuilles.*
+
+### Exercice :
+1. Quelle est la taille du tableau qui permet de représenter cet arbre ?
+
+![fig19.png](assets/fig19.png)
+
+2. Ecrire le tableau représentant cet arbre et le stocker dans une variable **t**
+
+3. Quelle propriété ont les indices des fils gauches et droits ?
+
+4. Voici un tableau représentant un arbre binaire:
+
+['*','-',5,2,6,None,None,None,None,None,None,None,None,None,None]
+
+
+Le dessiner. Que peut-il représenter ?
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+>  Voici un code python Python qui crée la liste représentant l'arbre de l'exercice 2
+
+
+
+```python
+def creation_arbre(r,profondeur):
+    """r : la racine (str ou int). la profondeur de l’arbre (int)"""
+    Arbre = [r]+[None for i in range(2**(profondeur+1)-2)]
+    return Arbre
+
+def insertion_noeud(arbre,n,fg,fd):
+    """Insére les noeuds et leurs enfants dans l’arbre"""
+    indice = arbre.index(n)
+    arbre[2*indice+1] = fg
+    arbre[2*indice+2] = fd
+
+# création de l’arbre
+arbre = creation_arbre("r",5)
+# ajout des noeuds par niveau de gauche à droite
+insertion_noeud(arbre,"r","a","b")
+insertion_noeud(arbre,"a","c","d")
+insertion_noeud(arbre,"b","e","f")
+insertion_noeud(arbre,"c",None,"h")
+insertion_noeud(arbre,"d","i","j")
+insertion_noeud(arbre,"e","k",None)
+insertion_noeud(arbre,"f",None,None)
+insertion_noeud(arbre,"h",None,None)
+insertion_noeud(arbre,"i",None,None)
+insertion_noeud(arbre,"j","m",None)
+insertion_noeud(arbre,"k",None,None)
+insertion_noeud(arbre,"m",None,None)
+
+#pour vérifier
+print(len(arbre))
+print(arbre)
+```
+
+    63
+    ['r', 'a', 'b', 'c', 'd', 'e', 'f', None, 'h', 'i', 'j', 'k', None, None, None, None, None, None, None, None, None, 'm', None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]
+
+
+### Exercice 3:
+1. Ecrire une fonction qui retourne le parent d'un noeud s'il est dans l'arbre et None sinon.
+2. Ecrire une fonction qui retourne **True** si l'arbre est vide
+3. Ecrire une fonction qui retourne les enfants d'un noeud.
+4. Un fonction qui renvoie le fils gauche d'un noeud s'il existe et None sinon
+5. Même question pour le fils droit
+6. Ecrire une fonction qui renvoie **True** si le noeud est la racine de l'arbre
+7. Ecrire une fonction qui renvoie **True** si le noeud est une feuille
+8. Ecrire une fonction qui renvoie **true** si le noeud comporte un frère gauche ou droit.
+
+**<u>Rappel : dans un tableau, si on note i l'indice d'un noeud, alors ses fils auront comme indice 2i +1 et 2i +2.</u>**
+
+**<u>Inversement, pour trouver le parent d'un noeud, il faut vérifier : i // 2 - 1</u>**
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+---------
+
+## Une seconde façon de faire...
+
+Comme vous l'avez sans doute constaté, il est assez fastidieux de représenter un arbre avec un unique tableau surtout pour un arbre très profond.
+
+L'idée est de représenter l'arbre ave cun tableau contenant des tableaux
+
+![fig20.png](assets/fig20.png)
+
+Cet arbre se représente par le tableau:
+
+['r', ['a', [ ], [ ]], ['b', [ ], [ ]]]
+
+### Exercice :
+Ecrire le tableau représentant l'arbre ci-dessous et le stocker dans une variable **t**
+
+![fig21.png](assets/fig21.png)
+
+**Le code Python ci-dessous, construit l'arbre de l'exercice 1 de manière récursive.**
+
+* Les noeuds sont représentés par un dictionnaire.
+* L'arbre se construit depuis la racine en construisant les sous-arbres des fils gauche et droit.
+
+
+```python
+def noeud(nom, fg =None, fd =None):
+    return{'racine': nom, 'fg' : fg, 'fd': fd}
+
+# création des noeuds
+k = noeud('k')
+f = noeud('f')
+e = noeud('e', k,None)
+b = noeud('b', e, f)
+m = noeud('m')
+j = noeud('j', m,None)
+i = noeud('i')
+d = noeud('d', i, j)
+h = noeud('h')
+c = noeud('c',None, h)
+a = noeud('a', c, d)
+racine = noeud('r', a, b)
+# création de l’arbre
+def construit(arbre):
+    if arbre is None:
+        return [ ]
+    else:
+        return [arbre['racine'],construit(arbre['fg']),construit(arbre['fd'])]
+
+arbre1 = construit(racine)
+print(arbre1)
+```
+
+    ['r', ['a', ['c', [], ['h', [], []]], ['d', ['i', [], []], ['j', ['m', [], []], []]]], ['b', ['e', ['k', [], []], []], ['f', [], []]]]
+
+
+### Exercice : 
+Ecrire toutes les fonctions de l'exercice 3 dans le cas de cette implémentation de l'arbre.
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+Nous allons maintenant nous intéresser à la hauteur de l'arbre, ainsi qu'aux différentes façons de le parcourir:
+* Le parcours en largeur
+* Le parcours en profondeur (parcours fixe, parcours infixe et parcours suffixe).
+
+**Calcul de la hauteur de l'arbre:**
+L'idée ets la suivante:
+* Si l'arbre est vide, la hauteur vaut -1
+* Sinon la hauteur vaut 1 auquel il faut ajouter le maximum entre les hauteurs des sous arbres gauche et droit.
+* Ces sous-arbres sont eux même des arbres dont il faut calculer la hauteur.
+
+Une méthode **récursive** semble donc tout à fait adaptée à la situation.
+
+Voici l'algorithme:
+
+![fig22.png](assets/fig22.png)
+
+### Exercice :
+1. Ecrire cette fonction pour l'arbre précédent et vérifier que sa profondeur est de 4.
+
+
+```python
+
+```
+
+## Les parcours
+
+**Le parcours en largeur:**
+Le parcours en largeur d'un arbre consiste à partir de la racine. On visite ensuite son fils gauche puis sont fils droit, puis le fils gauche du fils gauche etc... Comme le montre le schéma ci-dessous:
+
+![fig23.png](assets/fig23.png)
+
+
+L'idée est la suivante:
+
+On utilise une File.
+* On met l'arbre dans la file.
+* Puis tant que la file n'est pas vide:
+    * On défile la file
+    * On récupère sa racine
+    * On enfile son fils gauche s'il existe
+    * on enfile son fils droit s'il existe
+    
+
+Voici l'algorithme:
+
+![fig25.png](assets/fig25.png)
+
+### Exercice 7
+
+1. Rappeler les fonction permettant de définir une structure de file en python.
+2. Implémenter alors cette fonction et l'essayer sur l'arbre précédent.
+
+
+```python
+
+```
+
+
+```python
+
+```
+
+**Les parcours en profondeur**
+On se balade autour de l'arbre en suivant les pointillés
+
+![fig24.png](assets/fig24.png)
+
+Voici un algorithme permettant de réaliser ce parcours:
+![fig26.png](assets/fig26.png)
+
+### Exercice 
+1. Proposer une fonction permettant de réaliser le parcours en profondeur d'un arbre
+
+
+```python
+
+```
+
+Dans le schéma ci-dessus, on a rajouté des "noeuds fantômes" pour montrer que l'on peut considérer que chaque noeud est visité trois fois:
+* une fois par la gauche
+* une fois par en dessous
+* une fois par la droite
+
+### Definition:
+Dans un parcours **prefixe**, on liste le noeud la première fois qu'on le rencontre.
+
+
+### Exercice 
+1. Ecrire les sommets dans l'ordre d'un parcours préfixe
+
+
+
+### Definition:
+Dans un parcours **infixe**, on liste le noeud la seconde fois qu'on le rencontre.
+
+Ce qui correspond à:
+* On liste chaque noeud ayant un fils gauche la seconde fois qu'on le voit
+* on liste chaque noeud sans fils gauche la première fois qu'on le voit
+
+### Exercice 
+1. Ecrire les sommets dans l'ordre d'un parcours infixe
+
+
+
+### Definition:
+Dans un parcours **suffixe**, on note le noeud la dernière fois qu'on le rencontre.
+
+Exercice 11
+1. Ecrire les sommets dans l'ordre d'un parcours suffixe
+
+
+
+### Exercice 
+1. Voici trois algorithmes récursifs, dire pour chacun d'entre eux à quel parcours il correspond.
+![fig27.png](assets/fig27.png)
+![fig28.png](assets/fig28.png)
+![fig29.png](assets/fig29.png)
+2. Implémenter ces trois fonctions en python et confirmer les réponses des questions précédentes
+
+-------
+
+## Une troisième façon de faire.... en programmation objet
+
+Nous allons créer une classe **Noeud** dont les attributs d'instances seront:
+* le nom (ou valeur) de la racine
+* son fils gauche (None par défaut) ou de type Noeud
+* son fils droit (None par défaut) ou de type Noeud
+
+### Exercice 
+1. Implémentez cette classe Noeud
+2. Stocker l'arbre comme étant l'objet de type "Noeud" correspondant à la racine.
+3. Ecrire une méthode estFeuille qui renvoie True si le noeud est une feuille et False sinon
+4. Définir une fonction hauteur prenant comme argument un arbre permettant de renvoyer la hauteur de cet arbre
+5. Ecrire une méthode hauteur dans la classe Noeud permettant de faire la même chose
+6. Proposer des fonctions pour le parcours infixe, prefixe et suffixe pour cette façon de coder un arbre.
+7. Transformer alors vos fonctions en méthodes de la classe Noeud
+
+
+```python
+
+```
+
+-------
+
+### Sources
+
+- [Cours de Stephan Van Zulen](https://www.nsi-ljm.fr/NSI-TLE/co/section_chapitre3.html)
+- [Cours de Jeremy Camponovo](https://github.com/jcamponovo)

Temp/README.md

@@ -0,0 +1,96 @@
+## Structures Arborescentes
+
+> Structure présente partout dans le monde numérique, des répertoires de fichiers sur un ordinateur aux bases de données et algorithmes de recherche, les abres sont un pan essentiel de l'informatique. Ils permettent de structurer efficacement des données hiérarchiques et d’optimiser certaines opérations comme la recherche ou le tri. En NSI,  nous allons explorer une version particulière de ces structures : les arbres binaires.
+
+---------------------------------
+
+
+
+### Le programme
+
+
+
+<img src="assets/bo.png" alt="bo.png" style="zoom: 67%;" />
+
+
+
+
+
+### Définition
+
+<img src="assets/img1.png" alt="arbre_1" style="zoom: 50%;" />
+
+ **<u>*Attention, il y a quelques mots clés qui vont survenir dans les prochaines lignes !*</u>**
+
+
+
+- Un arbre est une structure de données hiérarchique et récursive, composée d’éléments appelés des **noeuds**.
+
+- Chacun de ces **noeuds** peut être étiqueté pour représenter une information.
+
+- Les **nœuds** d’un arbre sont reliés entre eux par des liens que l’on appelle souvent **arêtes** lorsque l'on parle de graphes (que nous verrons prochainement), mais en contexte arborescent, on parle couramment de **fils** pour désigner les connexions hiérarchiques.
+
+- **Un nœud parent** est relié à ses **nœuds enfants** par ces fils.
+
+  - Ces relations définissent la hiérarchie dans l’arbre.
+
+- Un lien “fils” est **orienté** : il part d’un parent vers un enfant.
+
+  - Ce lien structure la hiérarchie descendante, qui est essentielle pour le parcours de l’arbre (comme un arbre généalogique).
+
+  
+
+**Question** : *Pourquoi pensez-vous que cette structure est utilisée dans les systèmes informatiques ?*
+
+--------------
+
+### Caractéristiques d'un arbre
+
+Un arbre possède donc un nombre de noeuds, qu'on appelle **taille d'un arbre**. 
+
+**Question** : *Quelle est la taille de l'arbre représenté ci dessus ?*
+
+
+
+On parle également de **hauteur d'un arbre** : 
+
+- Elle correspond à la **profondeur maximale** d’un nœud dans l’arbre, c’est-à-dire le **plus grand nombre d’arêtes** depuis la racine jusqu’à une feuille.
+- La hauteur est le nombre maximum de niveaux dans l’arbre, en partant de la racine jusqu’à la feuille la plus profonde.
+- Selon les points de vue, la hauteur est parfois définie différemment : 
+  - On peut considérer la hauteur d'un arbre vide à 0, soit à 1.
+
+**Question** : *Quelle est la hauteur de l'arbre du dessus ?*
+
+
+
+-------
+
+### Arbres Binaires et Arbres binaires de recherche
+
+
+
+On appelle **Arbre Binaire (AB)** une structure de données hiérarchique dans laquelle chaque nœud peut avoir au maximum **deux enfants**, appelés fils gauche et fils droit. Les valeurs des nœuds n’ont pas de contrainte particulière.
+
+
+
+ Un **Arbre Binaire de Recherche (ABR)** est un arbre binaire dans lequel, pour chaque nœud :
+
+​	1.	Les valeurs des nœuds du **sous-arbre gauche** sont **strictement inférieures** à la valeur du nœud.
+
+​	2.	Les valeurs des nœuds du **sous-arbre droit** sont **strictement supérieures** à la valeur du nœud.
+
+À quoi cette structure sert-elle d'après vous ?
+
+
+
+### Conclusion
+
+Comprendre ces caractéristiques nous aidera à explorer comment manipuler efficacement ces structures pour chercher, insérer ou supprimer des données, et ce, très prochainement.
+
+----------------
+
+Auteurs : Florian Mathieu, Timothée Decoster, Enzo Frémaux
+
+Licence CC BY NC
+
+<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

Temp/TD.md

@@ -0,0 +1,58 @@
+# **Arbres binaires, arbres binaires de recherche, autres structures arborescentes**
+
+Soit les 4 arbres binaires suivant :
+
+<div style="display: flex; justify-content: space-around;">
+<img src="assets/img2.png" alt="Méthodes_natives" style="zoom: 80%;" />
+
+<img src="assets/img3.png" alt="Méthodes_natives" style="zoom: 80%;" />
+
+<div style="display: flex; justify-content: space-around;">
+<img src="assets/img4.png" alt="Méthodes_natives" style="zoom: 80%;" />
+<img src="assets/img5.png" alt="Méthodes_natives" style="zoom: 80%;" />
+</div>
+
+
+
+Question 1 - Compléter le tableau :
+
+|arbres |taille|hauteur|Profondeur de 4|profondeur de 5|profondeur de 6|
+|:-----:|:----:|:-----:|:-------------:|:-------------:|:-------------:|
+|arbre 1|      |       |               |               |               |
+|arbre 2|      |       |               |               |               |
+|arbre 3|      |       |               |               |               |
+|arbre 4|      |       |               |               |               |
+
+Question 2 - En utilisant la classe **BinnaryTree** du module ```arbres_binary_tree```, donner la définition :
+
+- en plusieurs affectations (plusieurs lignes) de l'arbre ayant pour racine le noeud **4** ;
+- en une seule affectation (une ligne) de l'arbre ayant pour racine le noeud **1**.
+
+![arbre binaire](assets/img6.png)
+
+Question 3 - Dessiner les arbres de ces définitions :
+
+```python
+vide = BinaryTree()
+
+# Premier arbre : F
+A = BinaryTree("A", vide, vide)
+E = BinaryTree("E", vide, vide)
+I = BinaryTree("I", vide, vide)
+
+B = BinaryTree("B", A, vide)
+D = BinaryTree("D", vide, E)
+H = BinaryTree("H", vide, I)
+
+C = BinaryTree("C", B, D)
+G = BinaryTree("G", vide, H)
+
+F = BinaryTree("F", C, G)
+
+# Deuxième arbre : J
+J = BinaryTree("A", BinaryTree("B", vide, BinaryTree("F", vide, vide)), BinaryTree("D", BinaryTree("E", vide, vide), BinaryTree("C", vide, vide)))
+```
+
+Question 4 - Parmi les 5 arbres binaires ci-dessous, lesquels sont des ABR ?
+
+![ABR?](assets/img7.png)

Temp/arbres_binary_tree.py

@@ -0,0 +1,114 @@
+__author__ = 'Timothée DECOSTER'
+__date_creation__ = 'Nov 15 18:37:07 2020'
+__doc__ = """
+:mod:`binary_tree` module
+:author: {:s} 
+:creation date: {:s}
+
+>>> t1 = BinaryTree()
+>>> t1.is_empty()
+True
+>>> t2 = BinaryTree(1, t1, t1)
+>>> t2.is_empty()
+False
+>>> t2.get_data()
+1
+>>> t2.get_left_subtree().is_empty()
+True
+>>> t2.get_right_subtree().is_empty()
+True
+>>> t2.is_leaf()
+True
+>>> print(t2)
+(1, (), ())
+""".format(__author__, __date_creation__)
+
+
+class BinaryTreeError(Exception):
+    def __init__(self, msg):
+        self.message = msg
+
+
+class BinaryTree():
+    def __init__(self, *args):
+        """
+        Binarytree Constructor
+
+        :param args: any, BinaryTree , BinaryTree (optional) (Node, Left Child Tree, Right Child Tree )
+        """
+        if len(args) == 0:
+            self.__content = None
+        elif len(args) != 3:
+            raise BinaryTreeError('bad arguments number for binary tree building')
+        elif not isinstance(args[1], BinaryTree) or not isinstance(args[2], BinaryTree):
+            raise BinaryTreeError('bad arguments type for binary tree building')
+        else:
+            self.__content = (args[0], args[1], args[2])
+
+    def is_empty(self):
+        """
+        :return: (bool) True iff this tree is empty
+        """
+        return self.__content is None
+        
+    def get_data(self):
+        """
+        :return: (any) Value saved in the root node
+        """
+        try:
+            return self.__content[0]
+        except TypeError:
+            raise BinaryTreeError('empty tree has no root')
+
+    def get_left_subtree(self):
+        """
+        :return: (BinaryTree) Left Child Subtree
+        """
+        try:
+            return self.__content[1]
+        except TypeError:
+            raise BinaryTreeError('empty tree has no left subtree')
+
+    def get_right_subtree(self):
+        """
+        :return: (BinaryTree) Right Child subtree
+        """
+        try:
+            return self.__content[2]
+        except TypeError:
+            raise BinaryTreeError('empty tree has no right subtree')
+
+    def __str__(self):
+        """
+        :return: (str) string representation of that tree
+        """
+        if self.is_empty():
+            return '()'
+        else:
+            repr_left = str(self.get_left_subtree())
+            repr_right = str(self.get_right_subtree())
+            return '({:s}, {:s}, {:s})'.format(str(self.get_data()), repr_left, repr_right)
+
+    def size(self):
+        """
+        :return: (int) numbre of Nodes in Tree
+        """
+        pass
+        
+    def height(self):
+        """
+        :return: (int) height of that tree
+        """
+        pass
+
+    def is_leaf(self):
+        """
+        :return: (bool) True iff tree is a leaf
+        """
+        pass
+
+if __name__ == '__main__':
+   import doctest
+   doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS, verbose=True)
+
+