* 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:
### 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:
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:
### 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
Voici un algorithme permettant de réaliser ce parcours:
### 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.
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)
