Arbre binaire

Représentation
On peut représenter un arbre binaire non vide par une structure récursive comme suit

Arbre :

    clef : int

    fg : Arbre # fils gauche

    fd : Arbre # fils droit

Poo (hors programme)

1
class arbre:

2
    def __init__(self,  val=None, g=None, d=None):

3
        self.clef = val

4
        self.gauche = g

5
        self.droit = d

7
    def __str__(self):

8
        res = str(self.clef)

9
        if self.gauche:

10
            res += str(self.gauche)

11
        if self.droit:

12
            res += str(self.droit)

13
        return res + '\n'

Listes

1
Arbre = [fg, clef, fd] # ou

2
Arbre = [clef, fg, fd] # avec clef : valeur, fg : list, fd : list

Représentez les arbres suivants

1
arg = arbre('‫'رغد‬,

2
            arbre('‫'ندى‬, 

 3
                  arbre('‫'نهى‬,

4
                        arbre('‫)'رهف‬,

5
                        arbre('‫))'قيس‬,

6
                  arbre('‫'علي‬, 

7
                        arbre('‫)'لين‬,

8
                        arbre('‫
))'شرف‬
9
                  ),

10
            arbre('‫'رضا‬, 

11
                  arbre('‫'ربى‬,

12
                        arbre('‫)'ريم‬,

13
                        arbre('‫))'وهب‬,

14
                  arbre('‫'صخر‬, 

15
                        arbre('‫)'هند‬,

16
                        arbre('‫
))'عمر‬
17
                  ),        

18
            )

1
# Pour le premier arbre

2
a1 = [1,

3
      [2, 

4
       [4, [], []],

5
       [5, 

6
        [7, [], []],

7
        [8, [], []]]], 

8
      [3, 

9
       [],

10
       [6, 

11
        [9, [],[]],

12
        []]]]

13
# ou en POO

14
a1 = arbre(1, 

15
           arbre(2, arbre(4), 

16
                 arbre(5, 

17
                       arbre(7),

18
                       arbre(8))),

19
           arbre(3, d=arbre(6, arbre(9))),

20
           )

Arbre 2

1
a2 = arbre('+', 

2
           arbre('*', 

3
                 arbre(1), 

4
                 arbre('-', 

5
                       arbre(2),

6
                       arbre(3))),

7
           arbre('+', 

8
                 arbre(4),

9
                 arbre(5)),

10
           )

Définissez une fonction evaluer() qui permet d'évaluer l'expression représentée par cet arbre.

↳ 1 cellule masquée
Définissez une fonction coder(arbre) qui permet d'écrire l'expression parenthésée équivalente
à cet arbre sous forme de str.

[ ] ↳ 1 cellule masquée

Définissez une fonction miroir(arbre) qui calcule l'image miroire de l'arbre (arbre de droite à
gauche).

[ ] ↳ 4 cellules masquées

Définissez une fonction nfeuilles(arbre) qui retourne le nombre de feuilles de l'arbre passé
en argument.

[ ] ↳ 4 cellules masquées

Parcours en profondeur d'un arbre binaire.

Rappeler l'algorithme récursif pour parcourir (en profondeur) un arbre binaire puis fournir une
implémentation de cet algorithme.

[ ] ↳ 2 cellules masquées

Hauteur d'un arbre binaire

Donner une fonction pour calculer la hauteur d'un arbre binaire (longueur du plus long chemin de la racine à
une feuille).

[ ] ↳ 2 cellules masquées

Recherche d'un élément.

Donner une fonction pour déterminer la référence d'un noeud qui comporte une valeur donnée val dans un
arbre. Dans le cas où
l'arbre ne comporte pas cette valeur, retourner None.

[ ] ↳ 1 cellule masquée

Profondeur d'un élément.

Donner une fonction pour déterminer la profondeur d'un noeud qui comporte une valeur donnée clef dans un
arbre. Dans le cas où
l'arbre ne comporte pas cette valeur, retourner inf.

[ ] ↳ 1 cellule masquée

Somme des éléments d'un arbre

Donner une fonction pour calculer la somme des éléments d'un arbre.

[ ] ↳ 1 cellule masquée