TAD (1).pptx

PROBLEMATIQUE
DE LA RESOLUTION DE PROBLEME PAR ORDINATEUR
3
Problème
Utilisateur
PROCESSUS DE DEVELOPPEMENT
Solution

Dans un système multiprogrammé, deux processus peuvent se
retrouver en situation d’interblocage :
 Si P1 attend une ressource détenue par P2 pour s’exécuter et P2 en
fait de même. Chaque processus étant inactif, il ne peut se terminer
et libérer la ressource qu’attend l’autre pour s’exécuter.
 Cette situation d’interblocage peut impliquer un très grand nombre
de processus et altérer les performances globales de notre système.
EXEMPLE INTRODUCTIF
4
Comment détecter et résoudre les situations d’interblocage?

DEMARCHE DE L’INGENIEUR
5
Graphe
MODELE
REALITE
Problème Solution
Solution difficile
à retrouver
Problème Solution
Interblocage,
Altération des
performances
Description
Implémentation
et
validation
Recherche des circuits

PROBLEME D’INTERBLOCAGE DE
PROCESSUS
Processus du système multiprogrammé
Le processus A attend une ressource détenue par le processus B
Problème d’interblocage de 2 processus
P1 P2
(1)
,
A B
6

Un modèle
 Est le support de la communication entre l’analyste, le programmeur et
l’utilisateur;
 Fait abstraction de la réalité en la représentant par une vue subjective mais
pertinente;
 Simule le système étudié, le rend compréhensible en réduisant la complexité;
 Il existe des techniques disponibles dans la littérature pour réaliser les
traitements associés aux modèles;
INTERETS ET OBJECTIFS
DE LA MODELISATION
7

ALGORITHME DE MARIMONT
Var
𝐺, 𝐻 : graphe
𝐸, 𝑆 : Ensemble de sommets
𝐻𝑣𝑖𝑑𝑒 : booléen
Début
𝐻 ← 𝐺
𝐻𝑣𝑖𝑑𝑒 ← 𝑣𝑖𝑑𝑒(𝐻)
E ← 𝑝𝑜𝑖𝑛𝑡_𝑒𝑛𝑡𝑟𝑒𝑒(𝐻)
S ← 𝑝𝑜𝑖𝑛𝑡_𝑠𝑜𝑟𝑡𝑖𝑒(𝐻)
Tant que ¬𝐻𝑣𝑖𝑑𝑒 et 𝐸 ≠ ∅ et S ≠ ∅
𝐻 ← 𝐸 ∪ 𝑆
𝐻 ← 𝑠𝑜𝑢𝑠_𝑔𝑟𝑎𝑝ℎ𝑒(𝐻, 𝑉)
𝐸 ← 𝑝𝑜𝑖𝑛𝑡_𝑒𝑛𝑡𝑟𝑒𝑒(𝐻)
𝑆 ← 𝑝𝑜𝑖𝑛𝑡_𝑠𝑜𝑟𝑡𝑖𝑒(𝐻)
Fin tant que
Si ¬𝐻𝑣𝑖𝑑𝑒 alors il y a un ou plusieurs circuits
Fin
8

EXEMPLE
AVEC L’ALGORITHME DE MARIMONT
1
5 4
2 3
Point d’entrée (∈ 𝐸)
Point de sortie (∈ 𝑆)
1er sous graphe après
suppression des (𝐸 ∪ 𝑆) 9

IMPLEMENTATION
 Dans un programme, notre préoccupation
sera donc de représenter le graphe par les
structures de données existant dans
l'environnement de programmation
 Un graphe peut être représenté par une
liste d’arcs ou par une matrice de
booléens
10

EXEMPLE
REPRESENTATION DU GRAPHE ORIENTE
Sommets du
graphe
Entrée /sortie
P1 P2 P3 P4 P5
P1 faux vrai faux faux vrai
P2 faux faux vrai faux vrai
P3 faux faux faux vrai faux
P4 faux faux faux faux faux
P5 faux faux faux vrai faux
Nous obtenons à partir de l’exemple précédent le
tableau de correspondance des arcs suivant
• Un point d’entrée n’a que des “faux” sur sa colonne (P1 est un point d’entrée)
• Un point de sortie n’a que des “faux” sur sa ligne (P4 est un point de sortie) 11

12
VOCABULAIRE
Dans un langage de programmation, le type d’une variable peut être
considéré comme la définition en compréhension de l'ensemble des
valeurs que peut prendre cette variable.
Type de donnée
Une structure de données est un agrégat de données sur lesquels on a
défini les opérations de haut niveau. En général, les structures de
données sont prédéfinies dans les environnements de développement.
Les structures de données couramment rencontrées sont : les tableaux
et les enregistrements.
Structure de données
Type abstrait de donnée (TAD)
Un type abstrait de donnée est une entité qui émerge dans un domaine
d’application lors de l’analyse. Il est généralement spécifié par un
modèle mathématique, lequel est constitué d’opérations applicables
sur cette entité.

13
SPECIFICTION D’UN TAD
Elle permet de comprendre la nature du TAD en s’appuyant sur des
exemples tirés sur la vie courante. Elle est généralement rédigée en
langage naturel.
Spécification externe ou fonctionnelle
La spécification d’un TAD se fait de trois(3) façons complémentaires
Elle consiste à identifier et à décrire les opérations applicables à un
TAD.
Spécification logique
Elle consiste à représenter un TAD en utilisant les ressources d’un
environnement de programmation. Cela revient à choisir les
structures de données qui vont représentées le TAD et programmer les
algorithmes correspondants aux opérations qui ont été définies sur ce
TAD.
Spécification physique (implémentation)

14
CONSTRUCTION D’UN TAD
DOMAINE
Fonctionnelle Logique Physique
ORDINATEUR
Objets
Types

15
NOTEZ BIEN
Spécifier ⟺ décrire
Modèle conceptuel (Quoi?) ⟶ spécification
Modèle organisationnel(Quand? Qui? Où?) ⟶ spécification
Implémentation (Comment?) ⟶ programmation
3.
Quelques exemples de TAD :
- Liste {file, pile}
- Arbre
- Table
- Ensemble
1.
⟶ : correspond à
Langage de programmation ≠ langage de spécification
2.

17
ETUDE DU TAD
LISTE
Spécification fonctionnelle
Une liste est une structure sur laquelle on peut faire les
remarques suivantes:
* Elle peut grandir ou rétrécir à un moment donné;
* Un élément peut être inséré ou supprimé à n’importe
quelle position de celle-ci;
* Elle peut être concaténée à plusieurs autres listes;
Si on considère la liste 𝑎1, 𝑎2, … , 𝑎𝑛 :
• 𝑎1 est le premier élément de la liste
• 𝑎𝑛 est le dernier élément de la liste
• Pour 1 < 𝑖 < 𝑛, 𝑎𝑖−1, est le prédécesseur de
𝑎𝑖 ; 𝑎𝑖+1 est le successeur de 𝑎𝑖
• Et cette liste est de longueur 𝑛.

18
ETUDE DU TAD
Liste
Spécification logique
SCHEME < Identificateur >
TYPE
< les entités structurant les descriptions >
VALUE
< les opérations spécifiées par les signatures >
AXIOM
< invariants >
END
Utilisation de RSL (Raise Specification Language)
T.A.D

19
EXEMPLE
DE SPECIFICATION LOGIQUE DU TAD Liste
SCHEME Liste
Type
T, ℕ, Liste
Value
vide : Liste
longueur : Liste → ℕ
supprimer : Liste × ℕ →Liste
insérer : Liste× ℕ × T→Liste
ieme : Liste× ℕ →T
T.A.D

20
EXEMPLE
DE SPECIFICATION LOGIQUE DU TAD Liste
Croisement des
observateurs et
générateurs
T.A.D
Axiome
∀𝑙 : Liste, ∀t: T, ∀𝑛, 𝑛1, 𝑛2 ∶ ℕ
-[longueur ° vide]
longueur (vide) = 0
- [longueur ° supprimer]
∀𝑙 : Liste, ∀𝑛: ℕ longueur (supprimer (𝑙, n)) = longueur (𝑙) – 1
- [longueur ° inserer]
∀𝑙 : Liste, ∀𝑛: ℕ , ∀t: T longueur (inserer(𝑙, n, t)) = longueur (𝑙) + 1
- [ieme° supprimer]
∀𝑙 : Liste, ∀𝑛, 𝑛1, 𝑛2 ∶ ℕ
𝑛1 < 𝑛2 ⇒ ieme (supprimer 𝑙, 𝑛1 , 𝑛2) = ieme(𝑙, 𝑛2 + 1) et
𝑛1 > 𝑛2 ⇒ ieme (supprimer 𝑙, 𝑛1 , 𝑛2) = ieme 𝑙, 𝑛2
- [ieme° inserer]
∀𝑙 : Liste, ∀t: T, ∀𝑛, 𝑛1, 𝑛2 ∶ ℕ
𝑛1 < 𝑛2 ⇒ ieme (inserer 𝑙, 𝑛1, 𝑡 , 𝑛2) = ieme(𝑙, 𝑛2 − 1) et
𝑛1 > 𝑛2 ⇒ ieme (inserer 𝑙, 𝑛1, 𝑡 , 𝑛2) = ieme 𝑙, 𝑛2
END

21
T.A.D
Signature des opérations associées au TAD
Liste
• Fonction longueur (var l: Liste): entier;
• Procedure inserer (var l: Liste, pos: entier, val: T);
• Procedure supprimer (var l: Liste, pos: entier);
• Fonction ieme (var l: Liste, pos: entier): entier; /* Si T est de type simple */
• Procedure ieme (var l: Liste, pos: entier, val: T); /* Si T est de type agrégé */

22
T.A.D
EXERCICE
On considère un polynôme représenté par la liste de ses
monômes, rangés par ordre de degrés décroissants.
Ecrire un programme qui permet de calculer la somme,
le produit et la dérivée de polynômes.
On vous suggère de commencer par étudier le sous
programme « ajout_monome » qui permet d’ajouter un
monôme à un polynôme. On peut avantageusement
spécifier un TAD « monome » avec les primitives
« degre » et « coefficient ».

23
T.A.D
La procédure ajout_monome
Procédure ajout_monome (𝑃 : polynome, 𝑚 : monome)
Var finpos, trouver : booléen;
𝑎, 𝑏, 𝑖, position : entier;
res, lemonome : monome;
𝑐: réel;
Début
Si longueur (𝑃 )=0 alors inserer (𝑃 , 1, 𝑚)
Sinon
Début
𝑖 ← 0;
𝑎 ← degre (𝑚);
Repéter
𝑖 ← 𝑖 +1;
ieme (𝑃 , 𝑖, lemonome);
𝑏 ← degre (lemonome);
trouver ← 𝑎 ≤ 𝑏;
finpol ← 𝑖= longueur (𝑃 );
Jusqu’à trouve ou finpos
position ← 𝑖;
fin

24
T.A.D
La procédure ajout_monome
si finpos et trouve alors
position ← longueur (𝑃 );
si (degre (lemonome) = 𝑎) alors
début
𝑐 ← coef (lemonome) + coef (𝑚);
supprimer (𝑃, position);
si 𝑐 <> 0 alors
début
creer_monome (𝑐, 𝑎, 𝑚 );
inserer (𝑃, position, res);
fin
fin
sinon inserer (𝑃, position, 𝑚 );
fin.

25
T.A.D
Autres opérations sur les monômes:
Liremonome, Egal
Comparer deux monômes
Procédure Egal(𝑚1 : monome, 𝑚2: monome) : booléen
Début
retourner( coef (𝑚1) = coef (𝑚2) et degre (𝑚1) = degre (𝑚2));
Fin
Fin procédure
Lire un monôme
Procédure liremonome (𝑚: monome)
Var d: entier;
c: réel;
début
lire (d);
lire (c);
creer_monome (c, d, 𝑚);
fin
Fin procédure

26
T.A.D
Somme de deux polynômes
Procédure SommePolynome (𝑃1 : polynome, 𝑃2: polynome, 𝑃: polynome)
Var i: entier ; 𝑚: monome ;
début
Pour i allant de 1 à longueur (𝑃1) faire
début
ieme (𝑃1, 𝑖, 𝑚);
inserer (𝑃, 𝑖, 𝑚);
fin
Pour i allant de 1 à longueur (𝑃2) faire
début
ieme (𝑃2, 𝑖, 𝑚);
ajout_monome (𝑃, 𝑚);
fin
fin
Fin procédure
Produit de deux monômes
Procédure Produitmonome (𝑚1 : monome, 𝑚2: monome, 𝑚: monome)
Début
creer_monome ( coef (𝑚1) * coef (𝑚2), degre (𝑚1) + degre (𝑚2));
Fin
Fin procédure
Autres opérations:
Produitmonome,
SommePolynome

27
T.A.D
Généralité et implémentation
Généralité:
Une liste est formée d’une séquence d’éléments d’un type donné,
dont le nombre peut être borné ou illimité
Deux structures de données pour implémenter une liste:
1. Implémentation statique par un tableau
2. Implémentation dynamique par des pointeurs
1
2

21
T.A.D
Implémentation du TAD Liste
Liste
𝒔𝒖𝒑𝒑𝒓𝒊𝒎𝒆𝒓
𝒊𝒏𝒔𝒆𝒓𝒆𝒓
𝒊𝒆𝒎𝒆
𝒍𝒐𝒏𝒈𝒖𝒆𝒖𝒓
Liste_tableau Liste_pointeur Faux_pointeur

29
Implémentation du TAD Liste :
par tableau
La notion de liste est très proche de celle d’un tableau. Le plus gros
problème réside dans le fait que la taille du tableau est statique
tandis que celle de la liste est dynamique.
Présentation
Info 1 Info 2 Info 3
1 2 3 taille
Début Fin
Tableau

30
par tableau
Cette implémentation oblige à faire une estimation du nombre
maximum d’éléments dans la liste car la dimension du tableau
utilisé doit être connu lors de la déclaration.
Les déclarations à utiliser pour l’implémentation du TAD Liste sous
forme de tableau se présentent comme suit :
Spécification physique
• Entraîne des temps de calculs importants
pour réaliser les insertions et les
suppressions (voir la complexité de leurs
algorithmes respectifs).
• En plus, la position et l’accès à une donnée
s’obtiennent par le biais de son indice.
constante max = 100 ;
type liste = Record
taille : entier ;
val : tableau[1.. max] de T ;
fin

31
T.A.D
par les tableaux
La longueur
• fonction taille (ref val:tableau[indice_min..indice_max] d'élément) : entier
début
retourner (indice_max ‐ indice_min + 1);
fin
Fin fonction
• fonction longueur (L: Liste) : entier
début
retourner (taille (L. val));
fin
Fin fonction

32
T.A.D
par les tableaux
Liste vide?
fonction est_vide (L: Liste) : booléen
début
retourner (L. val = vide);
fin
fin fonction
Ieme élément
Procédure ieme (L: Liste ; pos: entier, a: T)
var n : entier;
début
n ← taille (L.val);
Si (pos < n et est_vide (L)= faux) alors
a ← L.val[pos] ;
fin
Fin Procédure

33
T.A.D
par les tableaux
Tête de liste
fonction tete (L: Liste) : T
début
Si (est_vide (L)= faux) alors
retourner (L.val[pos]);
fin
Fin fonction
Dernier élément
fonction queue (L: Liste) : T
début
Si (est_vide (L)= faux) alors
retourner (L.val[n]);
fin
Fin fonction

34
T.A.D
par les tableaux
Supprimer un élément
Procédure supprimer (L: Liste ; pos: entier)
var n , i: entier;
début
pour i allant de pos à n-1 faire
L.val[i] ← L.val[i+1];
i ← i+1;
finpour
L.Taille ← L.Taille – 1;
fin Si
fin
Fin procédure

35
T.A.D
par les tableaux
Insérer un élément
Procédure inserer (L: Liste ; pos: entier ; valeur : T)
var n , i: entier;
début
pour i allant de n-1 à pos faire
L.val[i+1] ← L.val[i];
i ← i – 1;
finpour
L.val[pos] ← T;
L.Taille ← L.Taille +1;
fin Si
fin
Fin procédure

36
T.A.D
par les tableaux
Recherche l’index d’un élément
fonction recherche (L : Liste ; e : T) : entier
var i, n :entier;
début
n ← taille (L.val)
pour i allant de 1 à n faire
si T[i] = e alors
j ← i ;
finpour
retourner (j) ;
fin
Fin fonction

37
T.A.D
Par liste chainée
Peut être définie comme étant :
• Une liste chainée simple,
• Une liste doublement chainée,
• Une liste circulaire
Présentation
Elle est
constituée
d'éléments reliés
entre eux par des
pointeurs
Liste chainée dont le
dernier élément
pointe sur le premier
élément de la liste
Elle peut être simple
ou doublement
chainée
Chaque élément dispose
non plus d'un mais de
deux pointeurs
pointant respectivement
sur l'élément précédent
et l'élément suivant

38
T.A.D
par les pointeurs
Au travers de cette implémentation :
 Les manipulations d’objets représentés par des
suites sur lesquelles doivent s’effectuer de
nombreuses suppressions et de nombreux ajouts sont
rapides ( bien plus qu'avec des tableaux).
 La dimension évolue selon les actions.
 La position d’une donnée s’obtient par le biais de
son adresse.
 L’accès à une donnée s’effectue séquentiellement
par le (s) pointeur (s) de chaque élément.

39
T.A.D
par les pointeurs
Type
Liste_pointeur, T, ℕ
value
contenu: T;
suivant : Liste
Une liste chaînée simple ne peut être parcourue que du premier vers le
dernier élément de la liste.
Type
Liste_pointeur, T, ℕ
value
contenu: T;
precedent: Liste
suivant : Liste
Une liste doublement chaînée peut être parcourue dans un double sens : du
premier vers le dernier élément de la liste, et vice versa.

40
T.A.D
Implémentation du TAD Liste
Une liste (chainée simple) est un pointeur et son premier élément
Une variable est un pointeur vers une case mémoire
cas de la liste chainée simple
elt2 A003
elt1 A002 elt3 A004 elt4 A005 elt5 null
A001 A002 A003 A004 A005
adresse
contenu
adresse du
suivant
Élément de
la liste

41
T.A.D
Quelques méthodes dans une liste chainée
simple
Liste vide?
fonction est_vide (L: Liste) : booléen
début
retourner (L. suivant = nil);
fin
fin fonction
Tête de liste
fonction tete (L: Liste) : T;
début
retourner (L.contenu) ;
fin
Fin fonction
Dernier élément
fonction queue (L: Liste) : T
début
retourner (L.suivant);
fin
Fin fonction

42
T.A.D
Recherche dans une liste chainée simple
Recherche itérative
fonction est_present (L: Liste, a: T) : booléen
Var trouve: booléen;
début
trouve ← faux ;
Tant que (L <>nil) faire
Si (L. contenu = a) alors
trouve ← vrai ;
fin tantque
retourner (trouve) ;
fin
fin fonction
Recherche récursive
fonction est_present (L: Liste, a: T) :
booléen
Var trouve: booléen;
Début
Si (L=nil) alors
retourner (faux) ;
Si (L. contenu = a)
retourner (trouve) ;
retourner est_present (L.suivant) ;
fin
Fin fonction

43
T.A.D
Suppression dans une liste chainée simple
Suppression d’un élément de la liste
fonction supprimer (L: Liste, a: T) : Liste
début
Si (L = nil) alors
retourner (L);
Si (L. contenu = a) alors
retourner (L.suivant);
L.suivant ← supprimer (L.suivant, a);
retourner (L) ;
fin
fin fonction

44
T.A.D
Insertion dans une liste chainée simple
Sachant que les fonctions ‘tete’ et ‘queue’ retournent
respectivement la valeur en tête de liste et la queue de la
liste, considérons donc les axiomes suivants :
 tete (inserer (L, 𝑥)) = 𝑥 ;
 queue (inserer (L, 𝑥)) = L ;
Et si L<> nil
 inserer (tete (L), queue (L)) = L ;
Fonction insererEntete (L : Liste, a: T) : Liste
Début
L.suivant ← L ;
L.contenu ← a ;
retourne (L);
Fin
Fin fonction
Fonction insererEnqueue (L : Liste, a: T): Liste
Début
si L<> nil alors
début
L ← insererEntete (L, a);
retourne (L) ;
fin
retourne (insererEnqueue (L.suivant, a) ) ;
fin
Fin fonction

45
T.A.D
(suite)
Insérer un élément ‘ a’avant l’élément ‘b’de la liste
fonction inserer (L: Liste, a: T, b: T) : Liste
Var 𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟, 𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟, 𝐿0: Liste ;
début
𝐿0.contenu ← a ;
𝐿0.suivant ← nil ;
si (L = nil)
début
L.contenu ← a ;
retourner (L);
fin
𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟 ← L ;
𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟 ← L.suivant ;
Tant que ( (𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟 <>nil) et (𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟.contenu <> b)) faire
𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟 ← 𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟.suivant ;
𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟 ← 𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟.suivant ;
fin tantque

46
T.A.D
(suite et fin)
si (𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟 <> nil)
début
𝐿0.suivant ← 𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟;
𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟.suivant ← 𝐿0;
fin
retourne (L);
fin
Fin fonction

47
T.A.D
Remarque
structuration en
arbre
structuration en
liste
Sur un ensemble,
on peut définir
plusieurs types de
structures
Dans une liste
(chainée), un
élément a un seul
représentant
suivant, tandis
qu’il y en a
plusieurs dans un
arbre

49
Généralités sur le TAD Arbre
Définition
Soit 𝐴 un ensemble tel que 𝐶𝑎𝑟𝑑(𝐴) est fini. Sur 𝐴, on définit
la relation binaire 𝑃 ayant les propriétés suivantes :
i. ∃! 𝑎 ∈ 𝐴 tel que ∀𝑥 ∈ 𝐴, ¬𝑃(𝑥, 𝑎)
ii. ∀𝑥 ∈ 𝐴, ∃𝑖 ≥ 0 tel que 𝑃𝑖(𝑎, 𝑥)
iii. ∀𝑦 ∈ 𝐴, 𝑦 ≠ 𝑎, ∃! 𝑥 ∈ 𝐴 tel que 𝑃(𝑥, 𝑦)
P ‘induit’ une structure d’arbre sur A
 𝑎 est la racine de l’arbre
 Les éléments 𝑥 ∈ 𝐴, tel que ∀𝑦 ∈ 𝐴, ¬𝑃(𝑥, 𝑦)
sont appelés feuilles, nœuds, terminaux
 Si 𝑃(𝑥, 𝑦) alors
• 𝑥 est le père de 𝑦
• 𝑦 est le fils de 𝑥
 Si 𝑃𝑖(𝑥, 𝑦)
• 𝑥 est l’ancêtre de 𝑦
• 𝑦 est descendant de 𝑥
On dit aussi qu’il y a un chemin allant de 𝑥 à 𝑦

50
Arbre ordonné
Définition
Soit 𝐴 un ensemble sur lequel est définit un arbre.
Lorsque 𝐹𝑖𝑙𝑠 𝑥 ≠ 0, on peut définir sur 𝐹𝑖𝑙𝑠 𝑥 une
relation binaire notée 𝐹𝑥 vérifiant les propriétés
suivantes :
𝐹𝑖𝑙𝑠 𝑥 = 𝑦 ∈ 𝐴 ∕ 𝑃(𝑥, 𝑦)
i. ∃! 𝑃𝑓 𝑥 ∈ 𝐹𝑖𝑙𝑠 𝑥 , 𝑡𝑒𝑙 𝑞𝑢𝑒 ∀𝑦 ∈
𝐹𝑖𝑙𝑠 𝑥 , ¬𝐹𝑥 𝑦, 𝑃𝑓 𝑥
 𝑃𝑓 𝑥 est le premier fils de 𝑥
 ∃! 𝑑𝑓 𝑥 ∈ 𝐹𝑖𝑙𝑠 𝑥 , 𝑡𝑒𝑙 𝑞𝑢𝑒 ∀𝑦 ∈
𝐹𝑖𝑙𝑠 𝑥 , ¬𝐹𝑥(𝑑𝑓 𝑥 , 𝑦)
ii. ∀𝑦 ∈ 𝐹𝑖𝑙𝑠 𝑥 ∃𝑖 ≥ 0 𝑡𝑒𝑙 𝑞𝑢𝑒 𝐹𝑥
𝑖
(𝑃𝑓 𝑥 , 𝑦)
iii. ∀𝑦 ∈ 𝐹𝑖𝑙𝑠 𝑥 , 𝑦 ≠ 𝑃𝑓 𝑥 , ∃! 𝑧 ∈
𝐹𝑖𝑙𝑠 𝑥 𝑡𝑒𝑙 𝑞𝑢𝑒 𝐹𝑥(𝑧, 𝑦)
𝑦 est le frère immédiatement plus jeune que 𝑧
T.A.D
Propriétés

51
Arbre binaire
Définition
Un arbre binaire est un arbre ordonné tel que chaque nœud a au
plus 2 fils. Dans ce cas, le premier fils est appelé fils gauche et le
deuxième fils, fils droit.
Type
arbre, R
Value
racine: R;
𝑆𝑔𝑎𝑢𝑐ℎ𝑒: arbre;
𝑆𝑑𝑟𝑜𝑖𝑡: arbre;
Arbre_vide: arbre;
On suppose que les éléments sont de type T. On peut ainsi définir
les opérations suivantes sur les arbres :
 𝑟𝑎𝑐𝑖𝑛𝑒 ∶ 𝑎𝑟𝑏𝑟𝑒 → 𝑅
 𝑔𝑎𝑢𝑐ℎ𝑒 ∶ 𝑎𝑟𝑏𝑟𝑒 → arbre
 𝑑𝑟𝑜𝑖𝑡𝑒 ∶ 𝑎𝑟𝑏𝑟𝑒 → 𝑎𝑟𝑏𝑟𝑒
 𝑐𝑟𝑒𝑒𝑟𝐴𝑟𝑏𝑟𝑒 ∶ 𝑅 𝑥 𝑎𝑟𝑏𝑟𝑒 𝑥 𝑎𝑟𝑏𝑟𝑒 → arbre
 𝑣𝑖𝑑𝑒 ∶ 𝑎𝑟𝑏𝑟𝑒 → booléen
 𝑓𝑒𝑢𝑖𝑙𝑙𝑒 ∶ 𝑎𝑟𝑏𝑟𝑒 → 𝑏𝑜𝑜𝑙é𝑒𝑛
T.A.D
Spécification logique d’un arbre binaire
Si A est un arbre alors :
• racine (A) obtient l’élément situé à la racine de A
• gauche (A) obtient le sous arbre gauche de A
• droite (A) obtient le sous arbre droit de A
• creerArbre (x, g, d) crée un arbre à partir d’un élément x de 𝑅 , et de
deux arbres constituant respectivement le sous arbre gauche et le
sous arbre droit
• vide (A) retourne “vrai” si A est vide et “faux” sinon
• feuille (A) retourne “vrai” si A est une feuille et “faux” sinon
Soit A un arbre binaire, et a, b des éléments de l’ensemble R. Etant donné le fait que
A est ordonné, il existe des méthodes ‘ max (A), inferieur (a, b), superieur (a, b),
min (A) lesquelles sont compatibles avec la relation binaire 𝐹𝑥 et les relations
d’ordre de l’ensemble R.

52
T.A.D
Arbre binaire
Parcours d’arbre
Parcours infixé (gauche racine droite)
Parcours préfixé (racine gauche droite)
Parcours post-fixé (gauche droite racine)
Procedure Parcours (A : arbre, var L : Liste ) ;
Procédure Parcours_infixe (A : arbre, var L : Liste) ;
Procédure Parcours_prefixe (A : arbre, var L : Liste) ;
Procédure Parcours_postfixe (A : arbre, var L : Liste) ;
Fonction Concat (L1 : Liste, L2 : Liste ): Liste ;
Les méthodes
Procédure racine (A : arbre, var r : R);
Procédure gauche (A : arbre, var Sg : arbre );
Procédure droite (A : arbre, var Sd : arbre );
Procédure creerArbre (elt : R, A : arbre, B : arbre, var Result : arbre );
Fonction vide (A : arbre) : booléen;
Fonction feuille (A : arbre ) : booléen;
Procédure inserer (elt : R, var A : arbre) ;

53
T.A.D
Exemples
Parcours d’un arbre binaire
1.) Considérons l’arborescence suivante :
16
r
14
15
12
Sg
Sgg
Sgg
18
17 20
Sd
Sdg Sdd
Légende
g → fils de gauche
d → fils de droite
r → racine
A
Parcours_infixe :
A → (12 14 15 16 17 18 19 20)
Sg → (17 18 20)
Sd → (12 14 15)
Parcours_infixe :
Sgg → (12)
Sgd → (14 15)
Sdg → (17)
Sdd → (18 20)

54
T.A.D
Exemples
Parcours d’un arbre binaire
2.)
*
-
+
b
a c d
Considérons l’expression “ (a + b) * (c – d) ”
ayant pour forme canonique l’arborescence
suivante :
Parcours préfixé : ( * ( + a b) ( - c d))
Parcours post-fixé : (( a b + ) (c d -) *)
Parcours infixé : (a + b) * (c – d)
Voir la
signature de
ces différents
parcours

55
T.A.D
Quelques méthodes appliquées à un arbre binaire
Construction d’un arbre
Procédure creerArbre ( elt : R, G : arbre, D : arbre, var A : arbre)
Début
A.racine ← elt;
A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒 ← G;
A. 𝑆𝑑𝑟𝑜𝑖𝑡 ← D;
fin
Fin procédure
Nombre d’éléments dans un arbre
Fonction nombre_elt (A : arbre) : entier
Début
si (A = nil) alors retourner (0);
retourner ( 1 + nombre_elt (𝑆𝑔𝑎𝑢𝑐ℎ𝑒) + nombre_elt (𝑆𝑑𝑟𝑜𝑖𝑡));
Fin
Fin fonction

56
T.A.D
Recherche d’un élément dans un arbre
Comparaison entre deux arbres : comparer leur structure
et leurs différents éléments
Fonction compareArbre ( A1 : arbre, A2 : arbre) : booléen
début
si (vide(A1)= vrai) retourner (vide(A2)≠faux);
si (vide(A2)= vrai) retourner (vide(A1)≠faux);
retourner ((A1.racine = A2.racine) et
(compareArbre (A1. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒, A2. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒)
et (compareArbre (A1. 𝑆𝑑𝑟𝑜𝑖𝑡, A2. 𝑆𝑑𝑟𝑜𝑖𝑡));
Fin
Fin fonction
Fonction recherche_élément (A :arbre, valeur : R) : booléen
début
Si ( vide(A)=vrai) alors retourner (faux);
Si (ravine(A)=valeur)) alors retourner (vrai);
retourner (recherche_élément (𝑆𝑔𝑎𝑢𝑐ℎ𝑒, valeur) ou
recherche_élément (𝑆𝑑𝑟𝑜𝑖𝑡, valeur));
fin
Fin fonction

T.A.D
Suppression la racine d’un arbre A
Fonction supprimer_racine (var A : arbre) : arbre
Var B :arbre;
Début
Si (vide (A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒) = vrai) retourner (𝑆𝑑𝑟𝑜𝑖𝑡);
Si (vide (A. 𝑆𝑑𝑟𝑜𝑖𝑡) = vrai) retourner (𝑆𝑔𝑎𝑢𝑐ℎ𝑒);
Sinon
Début
creerArbre ( max (A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒), supprimer_max (A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒), A. 𝑆𝑑𝑟𝑜𝑖𝑡, B);
Retourner (B);
Fin
Fin
Fin fonction
57
Suppression de l’élément maximal (selon la relation d’ordre sur R) de l’arbre A
Fonction supprimer_max (var A : arbre) : arbre
début
Si (vide(A. 𝑆𝑑𝑟𝑜𝑖𝑡) = vrai) retourner (A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒);
retourner (creerArbre (A.racine, A. 𝑆𝑔𝑎𝑢𝑐ℎ𝑒, supprimer_max (A. 𝑆𝑑𝑟𝑜𝑖𝑡));
Fin
Fin fonction

58
T.A.D
Suppression d’un élément ‘a’ dans un arbre A
Fonction supprimer ( elt : R, A : arbre) : arbre
Var
r: R; Sg, Sd : arbre;
Début
Si (vide (A)=vrai) alors retourner (A);
Sinon
début
racine (A, r);
gauche (A, Sg);
droit (A, Sd);
si (elt = r) alors
retourner (supprimer_racine (A));
si (inferieur (elt, r) alors
retourner (creerArbre (r, supprimer (elt, Sg), Sd));
sinon
retourner (creerArbre (r, Sg, supprimer (elt, Sd)));
Fin
creerArbre (r, Sg, Sd, A);
Fin
Fin fonction

59
T.A.D
EXERCICE
Un arbre binaire trié est un arbre binaire tel que « tous les nœuds »
du sous arbre gauche ont une valeur inferieure à celle de la racine qui
elle-même, est inférieure aux valeurs du sous arbre droit. Chacun de
ses sous arbres étant lui-même, un arbre binaire trié.
La méthode de tri, dite par arbre procède de la façon suivante :
A partir de la liste triée, on construit un arbre binaire trié. Puis faisant
le parcours infixé de cet arbre trié, on obtient une liste triée.
Considérons le problème où l’on cherche à insérer un nœud dans
un arbre binaire trié en cherchant à ce que l’arbre reste trié. On
procèdera de la façon suivante :
 Si l’arbre est vide, on l’initialisera avec l’élément à insérer
 sinon on le compare avec la racine de l’arbre.
o S’il est plus petit ou plus grand, on l’insère dans le sous
arbre gauche;
o sinon, on l’insère dans un dans le sous arbre droit.
Indications :
Ecrire la méthode permettant :
• De transformer une liste en un arbre
• D’insérer un élément dans un arbre
• D’implémenter le parcours infixe

60
T.A.D
Insertion d’un élément dans un arbre
Procédure inserer ( elt : R, var A : arbre)
Var
r: R;
Sg, Sd : arbre;
Début
Si (vide (A)=vrai) alors creerArbre (elt, Arbre_vide, Arbre_vide);
Sinon
début
racine (A, r);
gauche (A, Sg);
droit (A, Sd);
si (inferieur (elt, r) alors inserer (elt, Sg);
sinon inserer (elt, Sd);
Fin
creerArbre (r, Sg, Sd, A);
Fin
Fin procédure

61
T.A.D
Construction d’un arbre à partir d’une liste
Procédure ListArbre ( L : Liste, var A : arbre)
Var 𝑖 : entier;
elt : R;
Début
𝑖 ← 1;
Tant que (𝑖 <= longueur (L)) faire
elt = ieme( L, 𝑖) ; ( ou ieme (L, 𝑖, elt) si R est un type
abrégé)
inserer (A, elt) ;
𝑖 ← 𝑖 + 1;
Fintant que
Fin
Fin procédure

62
T.A.D
Quelques méthodes appliquées à un arbre
binaire
Parcours d’un arbre binaire : parcours infixe
Procédure parcours_infixe (A : arbre, var L : Liste)
Var 𝑆𝑔, 𝑆𝑑 : arbre;
r : R;
𝐿1, 𝐿2 : Liste;
Début
Si (vide (A) ≠ vrai) alors
début
gauche (A, 𝑆𝑔);
droit (A, 𝑆𝑑);
racine (A, r);
Parcours_infixe (𝑆𝑔, 𝐿1);
Parcours_infixe (𝑆𝑑, 𝐿2);
inserer (𝐿2, r, 1);
concat (𝐿1, 𝐿2, L);
fin
Fin
Fin procédure
Tri d’un liste
Procédure tri (var L : Liste)
var A : arbre;
début
ListArbre (L, A);
init_liste (L);
parcours_infixe (A, L);
fin
Fin procédure
init_liste étant
la méthode
initialisant une
liste

TAD (1).pptx

Contenu connexe

Similaire à TAD (1).pptx

TAD (1).pptx