La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Chapitre IV. Structures linéaires (piles, files, listes chaînées) Type de données abstrait Pile File Liste.

Présentations similaires


Présentation au sujet: "Chapitre IV. Structures linéaires (piles, files, listes chaînées) Type de données abstrait Pile File Liste."— Transcription de la présentation:

1 Chapitre IV. Structures linéaires (piles, files, listes chaînées) Type de données abstrait Pile File Liste

2 Introduction Du problème au programme : Deux démarches : (1)descendante construire un algorithme par raffinements successifs, Représentation des données : Type de Données Abstrait, Limplémentation concrète nest pas connue. (2)ascendante : on se donne une représentation concrète du type de données en terme dobjets du langage de programmation utilisé, ainsi que des procédures ou des fonctions correspondant aux opérations du type. (1) est plus avantageuse. En réalité, le processus de programmation est la combinaison des deux.

3 1.Type de données abstrait La conception dun algorithme complexe se fait toujours en plusieurs étapes qui correspondent aux raffinements successifs. La première version de lalgorithme est autant que possible indépendante dune implémentation particulière. En particulier la représentation des données nest pas fixée. A ce premier niveau les données sont considérées de manière abstraite : on se donne - une notation pour les décrire; - lensemble des opérations quon peut leur appliquer; - les propriétés de ces opérations. (ex. dans plusieurs langages de programmation on manipule le type « réel » sans forcément connaître la représentation interne)

4 Signature dun TDA(1) La signature dun type de données décrit la syntaxe du type (nom des opérations, type de leurs arguments), mais elle ne définit pas les propriétés (sémantique) des opérations du type. La signature dun type abstrait est la donnée : - de noms dun certain nombre densembles des valeurs (ex.Booléen, Entier, Liste) – « sortes » (types). La définition dun type fait souvent intervenir plusieurs sortes -de noms dun certain nombre dopérations et de leurs profils; le profil précise à quels ensembles de valeurs appartiennent les arguments et le résultat dune opération.

5 Signature dun TDA(2) Type Vecteur, utilise Elément,Entier Opérations i-ème :Vecteur x Entier->Elément changer-i-ème : Vecteur x Entier x Elément ->Vecteur bornesup : Vecteur->Entier borneinf: Vecteur->Entier Opérations : avec arguments et sans arguments. Une opération qui na pas darguments est une constante Exemple : 0: ->Entier Vrai:->Booléen Hiérarchie des types, « sortes » prédéfinis.

6 Axiomes(1) Problème : donner une signification (une sémantique) aux noms de la signature : sortes et opérations; Enoncer les propriétés des opérations sous formes daxiomes. Exemple (pour Vecteur) Axiome 1 Borneinf(v) i-ème(changer-ième(v,i,e),i)=e v,i,e sont des variables respectivement de sortes Vecteur, Entier et Elément Signification : si i est compris entre les bornes dun vecteur v, quand on construit un nouveau vecteur en changeant le i -ème élément du vecteur v par e et ensuite on accède au i -ème élément, on obtient e Cette propriété est satisfaite quelles que soient les valeurs, de sortes convenables, données aux variables, (axiome)

7 Axiomes(2) Axiome (2) Borneinf(v)i-ème(changer-ième(v,i,e),j)=i-ème(v,j) Signification : seul le i-ème élément a changé dans le nouveau vecteur. La définition dun TDA est donc composée dune signature et dun ensemble daxiomes. Les axiomes sont accompagnés dun certain nombre de variables. Ce type de définition sappelle une définition algébrique ou axiomatique dun type abstrait. Problème de consistance (pas daxiomes contradictoires) Problème de complétude (est-ce que lensemble des axiomes proposé est suffisant ). Pour les types abstraits algébriques la règle de complétude est définie comme « on doit pouvoir déduire une valeur pour tous les observateurs sur tout objet dune sorte définie appartenant au domaine de définition de cet observateur. Le domaine de définition dune opération partielle est défini par une précondition.

8 Axiomes(3) Préconditions : Définissons une opération de « création » dun vecteur vide Vect : Entier x Entier ->Vecteur Avec les axiomes Borneinf(vect(i,j))=i Bornesup(vect(i,j))=j Lopération i-ème ne peut pas être appliquée sur un vecteur pour lequel on na pas de valeurs déléments. Une nouvelle opération qui « teste » si un élément a été associé à un certain indice : Init: Vecteur x Entier -> Booléen Axiomes : Init(vect(i,j),k)=faux (borneinf(v) (init(changerième(v,i,e),i)=vrai) (borneinf(v) (init(changer-ième(v,i,e),j)=init(v,j)) Précondition sur lopération i-ème : Lopération i-eme est définie ssi : Borneinf(v)

9 Structures linéaires. Pile Piles, Files, Listes font partie des structures dynamiques linéaires. Les opérations sur un ensemble dynamique peuvent être regroupées en deux catégories : –les requêtes (consultation); –les opérations de modification. Les opérations classiques : rechercher(S,clé), Insertion(S,elt), Supression(S,elt), Min(S),Max(S), Successeur(S,elt), Prédécesseur(S,elt)…

10 Pile Pile est un ensemble dynamique dans lequel lélément supprimé est celui le plus récemment inséré : dernier entré-premier sorti LIFO Opérations : Insérer = Empliler Supprimer = Dépiler Valeur= Recherche (toujours lélément pointé par le sommet) Illustration graphique dans le cas dimplémentation par un tableau S N

11 TDA Pile Type Pile utilise Booléen, Elément Opérations Pile-vide : ->Pile {création dune pile vide PV(P)} Empiler : Pile x Element ->Pile {EP(P,a)} Dépiler : Pile ->Pile {supprimer le dernier DP(P)} Valeur : Pile->Elément {renvoie lélément au sommet sans modifier la pile VP(P)} Est-vide : Pile->Booléen {test si la pile est vide EV(P)} Les opérations Dépiler et Valeur ne sont définies que si la pile nest pas vide Dépiler(P) est-défini-ssi est-vide(P)=faux Valeur(P) est-défini-ssi est –vide(P)=faux Axiomes Dépiler(Emplier(P,e))=P Valeur(empiler(P,e))=e Est-vide(Pile-vide)=vrai Est-vide(Empiler(P,e))=faux

12 Evaluation dune expression A laide des opérations et des axiomes du TDA Pile évaluer lexpression suivante : EV(DP(DP(EP(EP(PV,a)),b)))?

13 Pile. Implémentation à laide dun tableau(1) Type Pile = enregistrement sommet : entier; elts : tabelau [1..lmax] dElement FinEnregistrement Procédure Pile-vide(réf P: Pile) Début P.sommet:=0; Fin Pile-vide; Procédure Empiler(réf P: Pile, val X : Elément); Procédure Dépiler(réf P: Pile); Fonction Valeur(val P: Pile) : Elément; Fonction Est-vide(val P: Pile) : Booléen;

14 Pile. Implémentation à laide dun tableau(2) Procédure Empiler(réf P: Pile, val X : Elément) Début Si P.sommet=lmax Alors Erreur « débordement » Sinon P.sommet:=P.sommet+1; P.elts[P.sommet]:=X; FinSi FinEmpiler Remarque : chacune des opérations (Empiler, Dépiler) consomme le temps en O(1) Problème: Expliquer comment implémenter deux piles dans un tableau A[1..n] de telle manière quaucune ne déborde à moins que le nombre total déléments des deux piles vaille n. Les opérations Empiler et Dépiler devront sexécuter dans un temps en O(1)

15 TDA File(1) Dans le cas dune file on fait les adjonctions à une extrémité, les accès et les suppressions à lautre extrémité. Les files sont aussi appelées FIFO ( first –in –first out) : premier-entré-premier-sorti Une file comporte une tête et une queue. Les éléments sont donc retirés et consultés dans la tête et rajoutés dans la queue TQ

16 TDA File(2) Type File utilise Booléen, Elément Opérations File-vide : ->File {création dune file vide FV(F)} Enfiler : File x Elément ->File {EF(F,a)} Défiler : File ->File {supprimer le dernier DF(F)} Valeur : File->Elément {renvoie lélément au sommet sans modifier la file VF(F)} Est-vide : File->Booléen {test si la file est vide EV(F)} Les opérations Défiler et Valeur ne sont définies que si la file nest pas vide Défiler(F) est-défini-ssi est-vide(F)=faux Valeur(F) est-défini-ssi est –vide(F)=faux Axiomes Est-vide(F)=vrai => Valeur(Enfiler(F,e))=e Est-vide(F)=faux => Valeur(Enfiler(F,e))=Valeur(F) Est-vide(F)=vrai => Défiler(Enfiler(F,e))= File-vide Est-vide(F)=faux => Défiler(Enfiler(F,e))=Enfiler(Défiler(F),e) Est-vide(File-vide)=vrai Est-vide(Enfiler(F,e))=faux

17 Représentation contiguë des files Moyens de représentation : tableau On fait progresser les indices modulo taille Lmax du tableau i i Lmax-1 j ij j i=j File vide File pleine ?

18 Représentation contiguë des files(2) Gérer les débordements (1) Enfiler j:=j+1 mod lmax Si j=i alors File-pleine sinon Si File-vide(F) alors i:=j; FSi Tab[j]:=e; FSI (2) Défiler Si !File-vide(F) i:=i+1 mod lmax e:=Tab[i]; Si i:=j alors j:=-1; i:=-1; FSi (3) File vide i=-1et j=-1

19 Listes chaînées(1) Une liste chaînée est une structure de données dans laquelle les objets sont arrangés successivement … … maillon pointeur élément nil Liste=pointeur

20 Listes chaînées(2) Type Liste = ^Maillon; Type Maillon = Enregistrement Elt : Elément; Suivant : Liste Fin; Déclaration dune liste : L : Liste

21 Listes Listes contigües : ex. tableau des entiers = liste contigüe des entiers Listes chaînées : adressage à laide de « Suivant » Définition récursive :

22 Listes Exemple (8,5,6,7,4,8) L:= L1:= L2:= L3:=… L5:= L6:=

23 TDA Liste(1) Opérations ListeVide? : Liste ->Booléen Tête : Liste->^Maillon Valeur : ^Maillon->Elément Successeur : ^Maillon->^Maillon EstDernier? : ^Maillon ->Booléen Longueur : Liste ->Entier Primitives dynamiques CréerListe : -> Liste Insérer Ième : Liste X Entier X Elément -> Liste Supprimer Ième : Liste X Entier ->Liste Insérer en Tête : Liste X Elément -> Liste Supprimer en Tête : Liste -> Liste

24 TDA Liste(3) Dautres opérations Ième : Liste X Entier ->Elément Premier : Liste -> Elément Fin : Liste ->Liste Exemple : L=(A,B,C) Premier(L)=A Fin(L)=(B,C) Insérer en Tête(L,D)=(D,A,B,C)

25 TDA Liste (2) Quelques axiomes : LListe-Vide=>Premier(L)=Valeur(Tête(L)) Fin(Insérer en Tête(L, E))=L LListe-Vide=>Successeur(Tête(L))= Tête(Fin(L))

26 Recherche dans une liste chaînée Recherche : Liste X Elément ->^Maillon Fonction Recherche(val L: Liste, E: Elément): Liste Var PX : Liste; Début PX:=Tête(L); Tant que PX nil et PX^.Elt E faire PX:=Successeur(PX); FTq Retourner PX; Fin Recherche

27 Insertion dans une liste chaînée Fonction InsérerenTête(ref L: Liste, val E: Elément) : Liste Var Tampon : Liste; new(Tampon);{allocation de mémoire) Début Tampon^.elt:=E; Tampon^.suivant:=Tête(L); L:=Tampon; Retourner L; Fin InserérenTête

28 Suppression dans une liste chaînée Supprimer Ième: Liste X Entier -> Liste Procédure SupprimerIème(ref L:Liste, val i: entier, ref erreur booléen); Var P, PP : Liste; Debut Si L = nil alors erreur:=vrai; sinon Si i=1 alors L:=Successeur(L); erreur:=faux; sinon P:=Tête(L); k:=1; Tant que P nil et k < i-1 PP:=P; P:=P^.suivant; k:=k+1; FTq Si P nil alors PP^.suivant=Successeur(P); erreur:=faux; FSi FinSupprimerIème


Télécharger ppt "Chapitre IV. Structures linéaires (piles, files, listes chaînées) Type de données abstrait Pile File Liste."

Présentations similaires


Annonces Google