CPGE AGADIR MP-PSI

TD : ARBRES

Exercice 1 : Arbre binaire

1. Ecrire une fonction nommée isbinary(tree) qui prend un arbre tree en argument et retourne True si
l'arbre est un arbre binaire et False sinon.
>>>isbinary([1,[2,[],[]],[3,[],[]]])
True
>>>isbinary([1,[2],[3],[4]])
False
>>>isbinary([1,[2,[20]],[3,[30]],[4,[40]]])
False

2. Ecrire la fonction checkmul(tree) qui prend un arbre tree en argument et vérifie si l'arbre respecte la
règle suivante et renvoie True (obéit à la règle) ou False sinon.

Règle : chaque nœud (à l'exception des feuilles) est égale au produit des valeurs de ses nœuds fils.
Remarque : chaque nœud contient un nombre et chaque interne a exactement deux fils:

15 7 35

3 5 3 5 7 5

-5 -1

(A) (B) (C)

>>>A=[15,[3,[],[]],[5,[],[]]]
>>>B=[7,[3,[],[]],[5,[],[]]]
>>>C=[35,[7,[],[]],[5,[ -5,[],[]],[ -1,[],[]]]]
>>>checkmul(A)
True
>>>checkmul(B)
False
>>>checkmul(C)
True

a
3. Ecrire une fonction nommée path_exists(tree,path) qui vérifie si
un chemin path donné existe dans un arbre binaire tree. Les nœuds de
b e
l'arbre contiennent des chaines de longueur un :'a', 'b', 'c',…
Un chemin existe dans un arbre si ce chemin peut être généré en allant
c d f g
d'un nœud parent à un nœud fils.
(A)
>>>A=['a',['b',[ 'c',[],[]],[ 'd',[],[]]],['e',[ 'f',[],[]],[ 'g',[],[]]]]
>>>path_exists(A,'eg')
True
>>>path_exists(A,'abf')

TD-ARBRES 1/5
False

Exercice 2 : Expression arithmétique

Soit l’arbre ci-contre représentant une expression arithmétique : -

1- Ecrire la fonction parcours(A) d’un tel arbre permettant de retourner une + +
chaine de caractères représentant l’expression arithmétique associée (ne
pas oublier les parenthèses) 3 4 *
+
>>> A=['-',['+',[3,[],[]],['*',[5,[],[]],['+',[7,[],
5 8 9
[]], *
[2,[],[]]]]],['+',[4,[],[]],['*',[8,[],[]],[9,[],
[]]]]]
7 2
>>> parcours(A) (A)
'(*(*3+(*5*(*7+2)))-(*4+(*8*9)))'

2- Ecrire la fonction récursive valExpression(A) qui permet d’évaluer une expression arithmétique
représentée par un arbre binaire.

>>> valExpression(A)
-28

Exercice 3 : Arbre binaire de recherche

Un arbre binaire de recherche (ABR) est un arbre étiqueté tel que pour tout nœud n :
- Tout nœud du sous arbre gauche a une valeur inférieure ou égale à la valeur de n.
- Tout nœud du sous arbre droit a une valeur supérieure à la valeur de n.
Exemple :

1- Ecrire la fonction récursive AfficherDecRec(A) qui affiche les valeurs de 8

l’arbre binaire de recherche A en ordre décroissant.
3 10
>>>A=[8,[ 3,[ 1,[],[]],[ 6,[ 4,[],[]],[ 7,[],[]]]],[ 10, [
9,[],[]],[]]]
1 6 9
>>>AfficheDecRec(A)
10 9 8 7 6 4 3 1 4 7

2- Ecrire la fonction itérative MaximumItr(A) qui retourne la plus grande valeur de l’arbre binaire de
recherche A non vide.

3- Ecrire la fonction récursive MaximumRec(A) qui retourne la plus grande valeur de l’arbre binaire de
recherche A non vide.

4- Ecrire la fonction récursive Recherche(v,A) qui retourne True si la valeur v est dans l’arbre binaire
de recherche A , False sinon.

5- Ecrire la fonction récursive Inserer(v,A) qui permet d’insérer la nœud v dans l’arbre binaire de
recherche A .
TD-ARBRES 2/5
>>>A=[8,[ 3,[ 1,[],[]],[ 6,[ 4,[],[]],[ 7,[],[]]]],[ 10,[ 9,[],[]],[]]]
>>>inserer(2,A)
>>>A
[8,[ 3,[ 1,[],[ 2,[],[]]],[ 6,[ 4,[],[]],[ 7,[],[]]]],[ 10,[ 9,[],[]],[]]]

8 8

3 10 3 10

1 6 9 1 6 9

4 2 4 7
7

Exercice4 : Arbre n-aire

Un arbre n-aire : Arbre dans lequel un nœud peut avoir n fils

Représentation d’un arbre n-aire
En Python, on peut représenter un arbre n-aire vide par une liste vide [] et un arbre n-aire non vide par une liste
comprenant 2 éléments [clé , fils]. Où fils est une liste des tous les sous arbres n-aires.
Exemple :

A= [] #A est un arbre vide

A= [1,[]] #A est un arbre qui contient un seul nœud (1)

A= [1,[ [2,[]] , [3,[]] ]]

A= [1,[ [2,[ [4,[]], [5,[]], [6,[]] ]] , [3,[]] ]]

A= [1,[ [2,[ [4,[]], [5,[]], [6,[]] ]] , [3,[ [7,[]],[8,[]]]] ]]

A= [1,[ [2,[ [4,[]], [5,[]], [6,[]] ]] , [3,[ [7,[]],[8,[ [9,[]],[10,[]],

[11,[]] ]]]] ]]

TD-ARBRES 3/5
Ecrire les fonctions :
 vide(a) : retourne True si l’arbre a est vide, False sinon
 val(a) : retourne la valeur de l’étiquette de la racine de l’arbre a.
 fils(a) : retourne la liste des arbres fils du nœud a.
 préfixe(a) : retourne la liste des valeurs des nœuds de l’arbre n-aire parcourue en profondeur préfixe.
 postfixe(a) : retourne la liste des valeurs des nœuds de l’arbre n-aire parcourue en profondeur postfixe.
 parcoursLargeur(a) : retourne la liste des valeurs des nœuds de l’arbre n-aire parcourue en largeur.
 nombreNoeud(a) : retourne le nombre de nœuds de l’arbre n-aires a.
 estFeuille(a) : qui determine si un nœud est feuille
 nombreFeuille(a) :
 hauteur(a) :

Exercice5 : Arbre binaire représenté par un dictionnaire

En Python, on peut représenter un arbre binaire vide par un dictionnaire vide {} et un arbre binaire non vide par un
dictionnaire comprenant 3 éléments :

{'r' : valeur racine ,

'g' : filsGauche ,
'd' : filsDroit
}
Exemple :

A= {} #A est un arbre vide

A={'r' : 12 ,
'g' : {},
'd' : {}
}
A={'r' : 12 ,
'g' : {'r' : 1 , 'g' : {}, 'd' : {} },
'd' : {'r' : 7 , 'g' : {}, 'd' : {} }
}
A={'r' : 12 ,
'g' : {'r' : 1 ,
'g' : { 'r' : 91 , 'g' : {}, 'd' : {} },
'd' : {'r' : 67 , 'g' : {}, 'd' : {}} },
'd' : {'r' : 7 , 'g' : {}, 'd' : {} }
}
A={'r' : 12 ,
'g' : {'r' : 1 ,
'g' : { 'r' : 91 ,
'g' : {},
'd' : {}
},
'd' : {'r' : 67 ,
'g' : {},

TD-ARBRES 4/5
 'd' : {}
}
},
'd' : {'r' : 7 ,
'g' : {},
'd' : {'r' : 82 ,
'g' : {},
'd' : {}
}
}
}
A={'r' : 12 ,
'g': { 'r' : 1 ,
'g' : {'r' : 91 ,
'g' : {},
'd' : {}
},
'd' : {'r' : 67 ,
'g' : {},
'd' : {}
}
},
'd': {'r' : 7 ,
'g' : {},
'd' : {'r' : 82 ,
'g' : { 'r' : 61 ,
'g' : {},
'd' : {}
},
'd' : {}
}
}
}

Réécrire toutes les fonctions vues au cours en utilisant un dictionnaire pour représenter un arbre binaire

TD-ARBRES 5/5