19/03/2020
1
Types Abstraits de Données(TAD)
1
19/03/2020
2
Définition
Un TAD est
• un ensemble de données
• Et un ensemble d’opérations permettant de gérer ces données
les détails de l’implantation restant cachés
2
19/03/2020
3
Spécification d’un type de données abstrait
• Un type de données abstrait (TDA, abstract data type ou ADT en anglais) est un ensemble d’éléments muni d’opérations agissant sur ses éléments.
• Définition
• Une spécification est composée de :
• la définition d’un certain nombre d’opérations avec leurs signatures (ensemble de départ et d’arrivée)
• des axiomes qui définissent le comportement
• des préconditions si les opérations sont partiellement définies.
3
19/03/2020
4
• Type de données abstrait :
• quelles sont les opérations
• quelles sont les propriétés intrinsèques
• des opérations
4
19/03/2020
5
• TAD : ...
• utilise : ...
• opérations :
• préconditions :
• ... def_ssi ...
• axiomes :
• FinTAD
5
19/03/2020
6
Exemple : TAD booléen
• TAD Booléens
• opérations :
• Vrai : Booléens Faux : Booléens
NOT : Booléens Booléens
OR : Booléens x Booléens Booléens AND : Booléens x Booléens Booléens
• axiomes :
• NOT(Vrai) = Faux ; NOT(Faux) = Vrai a ET Vrai = a ; a ET Faux = Faux
a OU Vrai = Vrai ; a OU Faux = a
• FinTAD
6
19/03/2020
7
• Trois catégories d’opérateurs:
• opérations de construction : T est résultat sans être argument.
• opérations d’accès (Selecteurs): T est argument sans être résultat.
• opérations de transformation (Modificateurs): T est argument et résultat.
7
19/03/2020
8
Les listes
8
19/03/2020
9
Les listes
• Généralités
Définition: Une liste est formée d’une séquence d’éléments d’un type donné.
Exemples : liste de candidats à un examen.
Une liste pourra être triée ou non.
9
19/03/2020
10
Liste- définition générale
•On peut définir une liste comme une suite finie de données de même type .
•Définition récursive.
Une liste est : –soit vide
–soit la juxtaposition d’un premier élément avec une autre liste
10
19/03/2020
11
Définition des opérations
• créer une liste vide
• tester si elle est vide
• accéder aux éléments
• accéder à la fin de la liste
• accéder au début de la liste
• si on est sur une position, accéder à la position suivante
• insérer un élément à une position
• supprimer un élément à une position
• détruire une liste
11
19/03/2020
12
• Accès aux éléments d’une liste
– Comment caractériser les opérations sur les listes?
• La recherche d’un élément dont on connaît une partie de l’information : pas d’ambiguïté
• L’insertion, la suppression et la consultation nécessitent la mention de la position où
s’effectue l’opération.
12
19/03/2020
13
• Les opérations
– Constructeur
• Créer une liste vide
– Modificateurs
• Insérer une valeur au début d’une liste
• Supprimer un élément d’une liste
• Supprimer tous les éléments d’une liste
13
19/03/2020
14
• Les opérations
– Sélecteurs
• Savoir si une liste est vide
• Obtenir la longueur d’une liste
• Déterminer la valeur du début d’une liste
• Rechercher un élément dans une liste
• Vérifier si une liste est égale à une autre liste
14
19/03/2020
15
• TAD Liste
• utilise : Entier, Element, Place
• opérations :
• liste_vide : Liste
• acces : Liste x Entier Place
• contenu : Place Element
• ième : Liste x Entier Element
• longueur : Liste Entier
• supprimer : Liste x Entier Liste
• inserer : Liste x Entier x ElementListe
• succ : Liste x Place Place
• préconditions:
• acces(L,k) défini_ssi1 k longueur(L)
• supprimer(L,k) défini_ssi1 k longueur (L)
• inserer(L,k,e) défini_ssi1 k longueur (L) +1
• ième(L,k) défini_ssi 1 k longueur (L)
• succ(L, p) défini_ssi pacces(L, longueur (L))
• Axiomes:
• Fin-Liste
15
19/03/2020
16
axiomes
• longueur (liste_vide) = 0
• longueur (supprimer(L, i)) = longueur(L)-1
• longueur (insérer(L, i, e)) = longueur(L)+1 ième(insérer(L, i, e), i) = e
• contenu(accès(L, i)) = ième(L, i)
• succ(accès(L, i)) = accès(L, i+1) avec
• liste L
• entier i
• élément e
16
19/03/2020
17
• signification des opérations : (spécification abstraite)
• acces(L, i) : opération générale d’accès à la position d’un élément de rang i de la liste L.
• supprimer(L, i) : suppression de l’élément de rang i de la liste L.
• inserer(L, i, e) : insérer l’élément e , à la place de l’élément de rang i dans la liste L.
• ième(L, i) : fournit l’élément de rang i de la liste.
17
19/03/2020
18
• Deux structures de données pour implémenter une liste:
1. Implémentation statique par un tableau 2. Implémentation dynamique par une liste
chaînée
18
19/03/2020
19
Implémentation par un tableau
– Représentation
– Oblige à faire une estimation du nombre maximum d’éléments dans la liste.
– Entraîne des temps de calculs importants pour réaliser les insertions et les
suppressions
taille info1 info2 info3
1 2 3
début fin
19
19/03/2020
20
•
Implantation par une liste chaînée
– Une liste chaînée est une structure de données dans laquelle les objets sont arrangés linéairement.
– Chaque élément de la liste devra indiquer l’adresse de l’élément suivant.
– Un élément est donc représenté par un couple composé d’une information et d’une adresse, appelé cellule.
20
19/03/2020
21
• Implantation par une liste chaînée
– Une liste chaînée est constituée d’un ensemble de cellules chaînées entre elles.
– C’est l’adresse de la première cellule qui détermine la liste
b
a c
liste
21
19/03/2020
22
Implémentation des listes chaînées en C
• typedef int element;
• typedef struct CELLULE cellule;
• typedef cellule * place ;
• typedef place liste ;
• struct CELLULE {
• element info ;
• place next ;
• } ;
22
19/03/2020
23
• void erreur(char *s){
• puts(s);getch();
• exit(-1);
• }
• place succ(place p){
• if (p->next==NULL)erreur("\n erreur: dernier element n a pas de succ");
• return p->next;
• }
• int est_vide(liste l){
• return l==NULL;
• }
23
19/03/2020
24
• int longueur(liste l){
• int lg=0;
• place p=l;
• while(p){
• lg++;
• p=p->next;
• }
• return lg;
• }
24
19/03/2020
25
• liste liste_vide(){return NULL;}
• void detruire(liste l){
• place p=l,q;
• while(p!=NULL){
• q=p->next;
• free(p);
• p=q;}
25
19/03/2020
26
• element contenu (liste l, place p){
• if (longueur(l)==0)erreur("erreur: liste vide");
• return p->info;
• }
• place acces(liste l, int i){
• if(i<0 || i>=longueur(l))erreur("erreur: rang invalide");
• if (i==0)return l;
• place p=l;int k;
• for(k=0;k<i;k++)p=p->next;
• return p;
• }
26
19/03/2020
27
• element ieme(liste l, int i){
• if(i<0 || i>longueur(l)-1)erreur("erreur:
rang invalide");
• return contenu(l, acces(l, i));
• }
27
19/03/2020
28
• place crer_cel(){
• place p;
• p=(place)malloc(sizeof(cellule));
• if(p==NULL)erreur("erreur de memoire");
• p->next=NULL;
• return p;
• }
28
19/03/2020
29
• liste inserer (liste l, int i, element e){
• if (i<0 || i >longueur(l))erreur("erreur:rang non valide");
• place pnew=crer_cel();
• pnew->info=e;
• if(i==0){
• pnew->next=l;
• l=pnew;
• }
• else{
• place p=l;int k;
• for(k=0;k<i-1;k++)p=p->next;
• pnew->next=p->next;
• p->next=pnew;
• }
• return l;
• }
29
19/03/2020
30
• liste supprimer(liste l, int i){
• place p;
• if (i<0 ||i>=longueur(l))erreur("erreur: rang invalide");
• if (i==0){p=l;
• l=l->next;
• }
• else{
• place q=acces(l, i-1);
• p=q->next;
• q->next=p->next;
• }
• free(p);
• return l;
• }
30
19/03/2020
31
• void afficher(liste l){
• place p=l;
• while(p){
• printf("%d\t",p->info);
• p=p->next;
• }
• }
31
