chapitre iv structures lin aires piles files listes cha n es n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Chapitre IV. Structures linéaires (piles, files, listes chaînées) PowerPoint Presentation
Download Presentation
Chapitre IV. Structures linéaires (piles, files, listes chaînées)

Loading in 2 Seconds...

play fullscreen
1 / 28

Chapitre IV. Structures linéaires (piles, files, listes chaînées) - PowerPoint PPT Presentation


  • 97 Views
  • Uploaded on

Chapitre IV. Structures linéaires (piles, files, listes chaînées). Type de données abstrait Pile File Liste. Introduction. Du problème au programme : Deux démarches : (1)descendante construire un algorithme par raffinements successifs,

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Chapitre IV. Structures linéaires (piles, files, listes chaînées)' - conner


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapitre iv structures lin aires piles files listes cha n es

Chapitre IV. Structures linéaires (piles, files, listes chaînées)

Type de données abstrait

Pile

File

Liste

introduction
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,
  • L’implémentation concrète n’est pas connue.
  • (2)ascendante : on se donne une représentation concrète du type de données en terme d’objets 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.
1 type de donn es abstrait
1.Type de données abstrait
  • La conception d’un algorithme complexe se fait toujours en plusieurs étapes qui correspondent aux raffinements successifs. La première version de l’algorithme est autant que possible indépendante d’une implémentation particulière. En particulier la représentation des données n’est 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;

- l’ensemble des opérations qu’on 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)

signature d un tda 1
Signature d’un TDA(1)
  • La signature d’un 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 d’un type abstrait est la donnée :
  • - de noms d’un certain nombre d’ensembles des valeurs (ex.Booléen, Entier, Liste) – « sortes » (types). La définition d’un type fait souvent intervenir plusieurs sortes
  • -de noms d’un certain nombre d’opérations et de leurs profils; le profil précise à quels ensembles de valeurs appartiennent les arguments et le résultat d’une opération.
signature d un tda 2
Signature d’un 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 n’a pas d’arguments est une constante
  • Exemple :
  • 0 : ->Entier
  • Vrai :->Booléen
  • Hiérarchie des types, « sortes » prédéfinis.
axiomes 1
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 d’axiomes.
  • Exemple (pour Vecteur)
  • Axiome 1
  • Borneinf(v)<i<Bornesup(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 d’un 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)
axiomes 2
Axiomes(2)
  • Axiome (2)
  • Borneinf(v)<i<Bornesup(v)& Borneinf(v)<j<Bornesup(v)&i!=j
  • ->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 d’un TDA est donc composée d’une signature et d’un ensemble d’axiomes.
  • Les axiomes sont accompagnés d’un certain nombre de variables. Ce type de définition s’appelle une définition algébrique ou axiomatique d’un type abstrait.
  • Problème de consistance (pas d’axiomes contradictoires)
  • Problème de complétude (est-ce que l’ensemble 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 d’une sorte définie appartenant au domaine de définition de cet observateur. Le domaine de définition d’une opération partielle est défini par une précondition.
axiomes 3
Axiomes(3)
  • Préconditions :
  • Définissons une opération de « création » d’un vecteur vide
  • Vect : Entier x Entier ->Vecteur
  • Avec les axiomes
  • Borneinf(vect(i,j))=i
  • Bornesup(vect(i,j))=j
  • L’opération i-ème ne peut pas être appliquée sur un vecteur pour lequel on n’a 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)<i<bornesup(v)->(init(changerième(v,i,e),i)=vrai)
  • (borneinf(v)<i<bornesup(v)&i!=j)->(init(changer-ième(v,i,e),j)=init(v,j))
  • Précondition sur l’opération i-ème :
  • L’opération i-eme est définie ssi :
  • Borneinf(v)<i<bornesup(v)&init(v,i)=vrai
  • *exemple en c++ ( accès à l’espace –mémoire non-alloué)
structures lin aires pile
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)…

slide10
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 d’implémentation par un tableau

N

S

tda pile
TDA Pile
  • Type Pile
  • utilise Booléen, Elément
  • Opérations

Pile-vide : ->Pile {création d’une 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 n’est 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

evaluation d une expression
Evaluation d’une expression
  • A l’aide des opérations et des axiomes du TDA Pile évaluer l’expression suivante :
  • EV(DP(DP(EP(EP(PV,a)),b)))?
pile impl mentation l aide d un tableau 1
Pile. Implémentation à l’aide d’un tableau(1)
  • Type Pile = enregistrement
  • sommet : entier;
  • elts : tabelau [1..lmax] d’Element
  • 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;

pile impl mentation l aide d un tableau 2
Pile. Implémentation à l’aide d’un 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;

FinSiFinEmpiler

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 qu’aucune ne déborde à moins que le nombre total d’éléments des deux piles vaille n. Les opérations Empiler et Dépiler devront s’exécuter dans un temps en O(1)

tda file 1
TDA File(1)
  • Dans le cas d’une file on fait les adjonctions à une extrémité, les accès et les suppressions à l’autre 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

T

Q

tda file 2
TDA File(2)
  • Type File
  • utilise Booléen, Elément
  • Opérations

File-vide : ->File {création d’une 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 n’est 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

repr sentation contigu des files
Représentation contiguë des files
  • Moyens de représentation : tableau

i<j

0

i

j

Lmax-1

i>j

0

j

i

Lmax-1

i=j

0

Lmax-1

File vide

i=j

Lmax-1

0

File pleine ?

On fait progresser les indices modulo taille Lmax du tableau

repr sentation contigu des files 2
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

listes cha n es 1
Listes chaînées(1)
  • Une liste chaînée est une structure de données dans laquelle les objets sont arrangés successivement

nil

élément

pointeur

maillon

Liste=pointeur

listes cha n es 2
Listes chaînées(2)
  • Type Liste = ^Maillon;
  • Type Maillon = Enregistrement

Elt : Elément;

Suivant : Liste

Fin;

Déclaration d’une liste :

L : Liste

listes
Listes
  • Listes contigües : ex. tableau des entiers = liste contigüe des entiers
  • Listes chaînées : adressage à l’aide de « Suivant »
  • Définition récursive :
listes1
Listes
  • Exemple
  • (8,5,6,7,4,8)
  • L:=<8,L1>
  • L1:=<5,L2>
  • L2:=<6,L3>
  • L3:=…
  • L5:=<8,L6>
  • L6:=
tda liste 1
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
tda liste 3
TDA Liste(3)
  • D’autres 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)
tda liste 2
TDA Liste (2)
  • Quelques axiomes :
  • L≠Liste-Vide=>Premier(L)=Valeur(Tête(L))
  • Fin(Insérer en Tête(L, E))=L
  • L≠Liste-Vide=>Successeur(Tête(L))=

Tête(Fin(L))

recherche dans une liste cha n e
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
insertion dans une liste cha n e
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
suppression dans une liste cha n e
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

FSi

FSi

FinSupprimerIème