SlideShare une entreprise Scribd logo
1  sur  63
Télécharger pour lire hors ligne
TYPES ABSTRAITS DE DONNEES
2
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.
16
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
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
n ← taille (L.val);
Si (est_vide (L)= faux) alors
retourner (L.val[n]);
fin
Fin fonction
34
T.A.D
Implémentation du TAD Liste :
par les tableaux
Supprimer un élément
Procédure supprimer (L: Liste ; pos: entier)
var n , i: entier;
début
n ← taille (L.val);
Si (pos < n et est_vide (L)= faux) alors
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
retourner (L.val[pos]);
fin
Fin procédure
35
T.A.D
Implémentation du TAD Liste :
par les tableaux
Insérer un élément
Procédure inserer (L: Liste ; pos: entier ; valeur : T)
var n , i: entier;
début
n ← taille (L.val);
Si (pos < n et est_vide (L)= faux) alors
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
retourner (L.val[pos]);
fin
Fin procédure
36
T.A.D
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
Implémentation du TAD Liste :
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
Insertion dans une liste chainée simple
(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
Insertion dans une liste chainée simple
(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
48
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
Quelques méthodes appliquées à un arbre binaire
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
Quelques méthodes appliquées à un arbre binaire
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
Quelques méthodes appliquées à un arbre binaire
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
Quelques méthodes appliquées à un arbre binaire
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
Quelques méthodes appliquées à un arbre binaire
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
63
T.A.D

Contenu connexe

Similaire à TAD (1).pptx

CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCSiratiSoufiane
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptxolfaharrabi2
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétudeSana Aroussi
 
Algorithmique programmation2018
Algorithmique programmation2018Algorithmique programmation2018
Algorithmique programmation2018salah fenni
 
Cours langage c
Cours langage cCours langage c
Cours langage ccoursuniv
 
la complexité des algorithmes en toute simplicité
la complexité des algorithmes en toute simplicitéla complexité des algorithmes en toute simplicité
la complexité des algorithmes en toute simplicitéSana REFAI
 
Algorithmique Amp Programmation (R Sum
Algorithmique  Amp  Programmation (R SumAlgorithmique  Amp  Programmation (R Sum
Algorithmique Amp Programmation (R SumAmy Isleb
 
Cours c#
Cours c#Cours c#
Cours c#zan
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdfMARYAM510573
 
Présentation Finale - Partie I.pptx
Présentation Finale - Partie I.pptxPrésentation Finale - Partie I.pptx
Présentation Finale - Partie I.pptxouassityoussef
 

Similaire à TAD (1).pptx (20)

CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
 
cours algorithme
cours algorithmecours algorithme
cours algorithme
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétude
 
Algorithmique programmation2018
Algorithmique programmation2018Algorithmique programmation2018
Algorithmique programmation2018
 
Introduction à Python
Introduction à PythonIntroduction à Python
Introduction à Python
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Cours langage c
Cours langage cCours langage c
Cours langage c
 
la complexité des algorithmes en toute simplicité
la complexité des algorithmes en toute simplicitéla complexité des algorithmes en toute simplicité
la complexité des algorithmes en toute simplicité
 
Theme 6
Theme 6Theme 6
Theme 6
 
Algo inf102 2007
Algo inf102 2007Algo inf102 2007
Algo inf102 2007
 
Algorithmique Amp Programmation (R Sum
Algorithmique  Amp  Programmation (R SumAlgorithmique  Amp  Programmation (R Sum
Algorithmique Amp Programmation (R Sum
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Chapitre 1 rappel
Chapitre 1   rappelChapitre 1   rappel
Chapitre 1 rappel
 
Cours c#
Cours c#Cours c#
Cours c#
 
Theme 7
Theme 7Theme 7
Theme 7
 
01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf01 - Introduction à Python chaines de caractères.pdf
01 - Introduction à Python chaines de caractères.pdf
 
Présentation Finale - Partie I.pptx
Présentation Finale - Partie I.pptxPrésentation Finale - Partie I.pptx
Présentation Finale - Partie I.pptx
 
INF355_Lecon2.pdf
INF355_Lecon2.pdfINF355_Lecon2.pdf
INF355_Lecon2.pdf
 

TAD (1).pptx

  • 2. 2
  • 3. PROBLEMATIQUE DE LA RESOLUTION DE PROBLEME PAR ORDINATEUR 3 Problème Utilisateur PROCESSUS DE DEVELOPPEMENT Solution
  • 4. 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?
  • 5. 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
  • 6. 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
  • 7. 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
  • 8. 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
  • 9. 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
  • 10. 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
  • 11. 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. 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. 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. 14 CONSTRUCTION D’UN TAD DOMAINE Fonctionnelle Logique Physique ORDINATEUR Objets Types
  • 15. 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.
  • 16. 16
  • 17. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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
  • 28. 21 T.A.D Implémentation du TAD Liste Liste 𝒔𝒖𝒑𝒑𝒓𝒊𝒎𝒆𝒓 𝒊𝒏𝒔𝒆𝒓𝒆𝒓 𝒊𝒆𝒎𝒆 𝒍𝒐𝒏𝒈𝒖𝒆𝒖𝒓 Liste_tableau Liste_pointeur Faux_pointeur
  • 29. 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. 30 Implémentation du TAD Liste : 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. 31 T.A.D Implémentation du TAD Liste : 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. 32 T.A.D Implémentation du TAD Liste : 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. 33 T.A.D Implémentation du TAD Liste : 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 n ← taille (L.val); Si (est_vide (L)= faux) alors retourner (L.val[n]); fin Fin fonction
  • 34. 34 T.A.D Implémentation du TAD Liste : par les tableaux Supprimer un élément Procédure supprimer (L: Liste ; pos: entier) var n , i: entier; début n ← taille (L.val); Si (pos < n et est_vide (L)= faux) alors 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 retourner (L.val[pos]); fin Fin procédure
  • 35. 35 T.A.D Implémentation du TAD Liste : par les tableaux Insérer un élément Procédure inserer (L: Liste ; pos: entier ; valeur : T) var n , i: entier; début n ← taille (L.val); Si (pos < n et est_vide (L)= faux) alors 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 retourner (L.val[pos]); fin Fin procédure
  • 36. 36 T.A.D Implémentation du TAD Liste : 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. 37 T.A.D Implémentation du TAD Liste : 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. 38 T.A.D Implémentation du TAD Liste : 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. 39 T.A.D Implémentation du TAD Liste : 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. 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. 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. 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. 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. 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. 45 T.A.D Insertion dans une liste chainée simple (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. 46 T.A.D Insertion dans une liste chainée simple (suite et fin) si (𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟 <> nil) début 𝐿0.suivant ← 𝑠𝑢𝑐𝑐𝑒𝑠𝑠𝑒𝑢𝑟; 𝑝𝑟𝑒𝑑𝑒𝑐𝑒𝑠𝑠𝑒𝑢𝑟.suivant ← 𝐿0; fin retourne (L); fin Fin fonction
  • 47. 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
  • 48. 48
  • 49. 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. 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. 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. 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. 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. 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. 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. 56 T.A.D Quelques méthodes appliquées à un arbre binaire 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
  • 57. T.A.D Quelques méthodes appliquées à un arbre binaire 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. 58 T.A.D Quelques méthodes appliquées à un arbre binaire 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. 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. 60 T.A.D Quelques méthodes appliquées à un arbre binaire 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. 61 T.A.D Quelques méthodes appliquées à un arbre binaire 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. 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