TP03 Les arbres -

Définitions et parcours -
Corrections proposées
> 1 de 5
TP 03 Les arbres binaires - Définitions et parcours -
Corrections proposées.
Gossoni Mohamed
[email protected]
Al khansa - CPGE MP

Exercice 1 (Représentation en Python)

Représenter en liste les arbres binaires suivants:

Réponse:

Entrée [2]: 1 a0 = [15, [], []]

2 a1 = [18, [12, [], [17, [], []]], [30, [15, [], []], []]]
3 a2 = [19, [42, [], [17, [10, [], []], []]], [15, [35, [], []], [12, [], []]]]
4

Exercice 2 (Fonctions de base)

Toutes les fonctions seront testées sur les trois arbres vus au premier exercice (et qu’on commencera par traiter à la main).

1. Écrire , une fonction décidant si un noeud d’un arbre binaire est feuille ou non.
Exemple:

>

Réponse:

Entrée [14]: 1 def est_feuille(a):

2 if a==[]:
3 return False
4 return a[1]==[] and a[2]==[]
5
6 list(map(est_feuille, [a0, a1, a2]))
7
Out[14]: [True, False, False]

2. Écrire une fonction calculant la hauteur d’un arbre binaire .

Exemple:

>

>
 TP03 Les arbres -
Définitions et parcours -
Corrections proposées
Réponse:
> 2 de 5

Entrée [15]: 1 # D'après la définition vue au cours. (Le nombre d'arêtes)

2 def hauteur(a):
3 if a==[] or est_feuille(a):
4 return 0
5 return 1+max(hauteur(a[1]),hauteur(a[2]))
6
7 # Si on considère la définition se basant sur le nombre de neouds.
8 def hauteur1(a):
9 if a==[]:
10 return 0
11 return 1+max(hauteur1(a[1]),hauteur1(a[2]))
12
13 list(map(hauteur, [a0, a1, a2]))
14
Out[15]: [0, 2, 3]

3. Écrire , une fonction calculant le nombre de noeuds d’un arbre binaire .

Exemple:

>

Réponse:

Entrée [3]: 1 def nb_noeuds(a):

2 if a==[]:
3 return 0
4 return 1+nb_noeuds(a[1])+nb_noeuds(a[2])
5
6 list(map(nb_noeuds, [a0, a1, a2]))
7
Out[3]: [1, 5, 7]

4. Écrire , une fonction calculant le nombre de feuilles d’un arbre binaire .

Exemple:

>

Réponse:

Entrée [5]: 1 def nb_feuilles(a):

2 if a==[]:
3 return 0
4 if a[1]==[] and a[2]==[]:
5 return 1
6 return nb_feuilles(a[1])+nb_feuilles(a[2])
7
8 # En utilsant est_feuille:
9 def nb_feuilles2(a):
10 if a==[]:
11 return 0
12 if est_feuille(a):
13 return 1
14 return nb_feuilles(a[1])+nb_feuilles(a[2])
15
16 list(map(nb_feuilles, [a0, a1, a2]))
17
Out[5]: [1, 2, 3]

5. Écrire , une fonction décidant si un noeud (sous arbre) d’un arbre binaire est interne ou non.
Exemple:
 TP03 Les arbres -
Définitions et parcours -
> Corrections proposées
> 3 de 5

Réponse:

Entrée [17]: 1 def est_interne(a):

2 if a==[]:
3 return False
4 return not est_feuille(a)
5
6 list(map(est_interne,[a0,a1[1][2],a2[1][2]]))
7
Out[17]: [False, False, True]

6. Écrire , une fonction calculant le nombre de noeuds internes d’un arbre binaire .
Exemple:

>

Réponse:

Entrée [18]: 1 def nb_internes(a):

2 if a==[] or est_feuille(a):
3 return 0
4 return 1+ nb_internes(a[1])+nb_internes(a[2])
5
6 list(map(nb_internes, [a0, a1, a2]))
7
Out[18]: [0, 3, 4]

Exercice 3 (Recherche)
Ecrire une fonction qui décide s'il existe un noeud de valeur dans un arbre binaire .
Exemple:

>

Réponse:

Entrée [8]: 1 def existe(a,x):

2 if a==[]:
3 return False
4 if a[0]==x:
5 return True
6 return existe(a[1],x) or existe(a[2],x)
7
8 list(map(existe, [a0, a1, a2],[18,18,18]))
9
Out[8]: [False, True, False]

Exercice 4 (Parcours en profondeur)

On va construire de façon récursive et selon les algorithmes vus au cours, la liste des étiquettes d’un arbre selon:

le parcours infixe (l’étiquette de la racine est au milieu).

le parcours préfixe (l’étiquette de la racine est au début).
le parcours suffixe (l’étiquette de la racine est à la fin). par les fonctions , et
 TP03 Les arbres -
1. a) Écrire en utilisant la concaténation de listes via l’opérateur . Définitions et parcours -
Corrections proposées
Exemple:
> 4 de 5

>

Réponse:

Entrée [9]: 1 def parcours_infixeV1(a):

2 if a==[]:
3 return []
4 return parcours_infixeV1(a[1])+[a[0]]+parcours_infixeV1(a[2])
5
6 list(map(parcours_infixeV1, [a0, a1, a2]))
7
Out[9]: [[15], [12, 17, 18, 15, 30], [42, 10, 17, 19, 35, 15, 12]]

b) Récrire en utilisant la méthode de list .

Réponse:

Entrée [5]: 1 def parcours_infixeAp(a,p):

2 if a!=[]:
3 parcours_infixeAp(a[1],p)
4 p.append(a[0])
5 parcours_infixeAp(a[2],p)
6
7 def parcours_infixeV2(a):
8 p=[]
9 parcours_infixeAp(a,p)
10 return p
11
12 list(map(parcours_infixeV2, [a0, a1, a2]))
13
Out[5]: [[15], [12, 17, 18, 15, 30], [42, 10, 17, 19, 35, 15, 12]]

2) Recommencer avec (pour le parcours préfixe), puis avec le (pour le parcours

suffixe).
Exemple:

>

>

Réponse:

Entrée [11]: 1 def parcours_prefixe(a):

2 if a==[]:
3 return []
4 return [a[0]]+parcours_prefixe(a[1])+parcours_prefixe(a[2])
5
6 def parcours_suffixe(a):
7 if a==[]:
8 return []
9 return parcours_suffixe(a[1])+parcours_suffixe(a[2])+[a[0]]
10
11 print(list(map(parcours_prefixe, [a0, a1, a2])))
12 print(list(map(parcours_suffixe, [a0, a1, a2])))
13
[[15], [18, 12, 17, 30, 15], [19, 42, 17, 10, 15, 35, 12]]
[[15], [17, 12, 15, 30, 18], [10, 17, 42, 35, 12, 15, 19]]

3) Ecrire la version itérative de .

 TP03 Les arbres -
Indication: On utilisera une pile pour stocker les noeuds pas encore visiter comme indiqué au cours.
Définitions et parcours -
Corrections proposées
Réponse: > 5 de 5

Entrée [12]: 1 def prefixe_iter(a):

2 if a==[]:
3 return []
4 P=[a]
5 R=[]
6 while P!=[]:
7 s=P.pop()
8 R.append(s[0])
9 if s[2]!=[]:
10 P.append(s[2])
11 if s[1]!=[]:
12 P.append(s[1])
13 return R
14
15 list(map(prefixe_iter, [a0, a1, a2]))
16
Out[12]: [[15], [18, 12, 17, 30, 15], [19, 42, 17, 10, 15, 35, 12]]

Exercice 5 (Parcours en largeur)

Par un raisonnement semblable à celui utilisé pour et en se référant au cours, écrire la fonction
retournant le parcours par niveau d'un arbre entré en paramètre.
Exemple:

>

Réponse:

Entrée [13]: 1 def parcours_largeur(a):

2 if a==[]:
3 return []
4 F=[a]
5 R=[]
6 while F!=[]:
7 s=F.pop(0)
8 R.append(s[0])
9 if s[1]!=[]:
10 F.append(s[1])
11 if s[2]!=[]:
12 F.append(s[2])
13 return R
14
15 list(map(parcours_largeur, [a0, a1, a2]))
16
Out[13]: [[15], [18, 12, 30, 17, 15], [19, 42, 15, 17, 35, 12, 10]]