Piles, files et listes: notions théoriques

Présentation au sujet: "Piles, files et listes: notions théoriques"— Transcription de la présentation:

1 Piles, files et listes: notions théoriques
Propriétés des structures linéaires Applications de chaque structure de données Spécifications algébriques Licence informatique Introduction à l’algorithmique. G. Hains

2 Propriétés des structures linéaires
Les structures de données dites linéaires sont les listes, les piles et les files. Listes: structures linéaires générales. Ce qui les caractérise est le parcours linéaire: on n’accède à une valeur qu’à travers les précédentes ou les suivantes. Insertion et effacement en un nombre constant d’opérations, mais l’accès prend plusieurs opérations. Pour un tableau ce serait le contraire. Piles: structures linéaires qu’on n’accède que par une de ses extrémités. Insertion, effacement uniquement par cette extrémité. On appelle parfois les piles les structures LIFO ou Last-in First-out c’est-à-dire dernier arrivé premier sorti, ce qui décrit le protocole d’insertion/effacement. File: structures linéaires qu’on accède par les deux extrémités mais une sert à l’insertion alors que l’autre sert à l’effacement uniquement. On appelle parfois les files les structures FIFO ou First-in First-out c’est-à-dire premier arrivé premier sorti, ce qui décrit le protocole d’insertion/effacement. Licence informatique Introduction à l’algorithmique. G. Hains

3 Applications des structures de données linéaires
Listes: Elles servent comme les tableaux à gérer dynamiquement des ensembles de valeurs. On les préfère aux tableaux quand on doit insérer-effacer souvent des valeurs et qu’un ordre existe entre les éléments. Les langages de programmation déclarative (de très haut niveau) s’en servent comme structure principale: Lisp, Scheme, Caml, ML, Haskell, Python, Prolog etc. Piles: On utilise une pile partout où il faut mémoriser son chemin et parfois rebrousser chemin: parcours d’un graphe (le fil d’Ariane est une pile), parcours d’un arbre, exécution des blocs d’un programme et des appels de fonctions, compilation d’un arbre syntaxique en langage cible etc. Files: On utilise une file quand il faut simuler une file d’attente et/ou conserver à la sortie l’ordre des éléments insérés à l’entrée: canal de communication, lecture/écriture d’un fichier, simulation de circuit intégré, simulation de systèmes à événements discrets (réseaux de transport, réseaux de télécom etc). Licence informatique Introduction à l’algorithmique. G. Hains

4 Spécifications algébriques
Les spécifications algébriques sont des ensembles de déclarations, comme les spécifications des paquetages Ada, auxquelles on ajoute des axiomes. Ces derniers représentent les propriétés dynamiques des structures de données et constituent un cahier des charges pour toute implantation correcte. Nous allons montrer des spécifications pour les piles, les files puis une pour les opérations les plus simples sur les listes et enfin une spécification plus complète pour des opérations sur les listes. Licence informatique Introduction à l’algorithmique. G. Hains

5 spec PILE0 {Piles generiques de taille non-bornee} etend BOOL0, NAT0
sorte S, Pile {S= sorte des objets de base en pratique on utilise PILE0[S:=Ma_sorte_preferee] } operations pilenouv: -> Pile { constructeur: pile vide } empiler: Pile S -> Pile { constructeur } depiler: Pile -> Pile remplacer: Pile S -> Pile { remplacer le sommet} sommet: Pile -> S vide: Pile -> Bool { vacuite } hauteur: Pile -> Nat preconditions p:Pile; x:S pre( sommet(p)) = ~ (vide(p)) pre( depiler(p)) = ~ (vide(p)) pre(remplacer(p,x)) = ~ (vide(p)) Licence informatique Introduction à l’algorithmique. G. Hains

6 (p1) vide(pilenouv) = vrai (p2) hauteur(pilenouv) = 0
axiomes p:Pile; x:S (p1) vide(pilenouv) = vrai (p2) hauteur(pilenouv) = 0 (p3) vide(empiler(p,x)) = faux (p4) hauteur(empiler(p,x)) = hauteur(p) + 1 (p5) sommet(empiler(p,x)) = x (p6) depiler(empiler(p,x)) = p (p7) remplacer(p,x) = empiler(depiler(p),x) fspec Licence informatique Introduction à l’algorithmique. G. Hains

7 spec FILE0 {Files generiques de taille non-bornee} etend BOOL0, NAT0
sorte S , File {S= sorte des objets de base} operations filenouv: -> File {constructeur: file vide} adjq: File S -> File {constructeur: adjoindre a la queue.} supt: File -> File {supprimer la tete} tete: File -> S {element de tete} vide: File -> Bool {vacuite} lgr: File -> Nat {longueur} preconditions pre(tete(f)) = ~ vide(f) pre(supt(f)) = ~ vide(f) axiomes p:Pile; x:S (f1) vide(filenouv) = vrai (f2) lgr(filenouv) = 0 (f3) vide(adjq(f,x)) = faux (f4) lgr(adjq(f,x)) = lgr(f) + 1 (f5) tete(adjq(f,x)) = si vide(f) alors x sinon tete(f) fsi (f6) supt(adjq(f,x)) = si vide(f) alors filenouv sinon adjq(supt(f),x) fsi fspec Licence informatique Introduction à l’algorithmique. G. Hains

8 spec LISTE0 {Listes generiques de taille non-bornee} etend BOOL0, NAT0
sorte S , Liste {S= sorte des objets de base} operations listenouv: -> Liste { constructeur: liste vide } adjt: Liste S -> Liste {constructeur: adjoindre a la tete} supt: Liste -> Liste { supprimer la tete} tete: Liste -> S { element de tete } vide: Liste -> Bool { vacuite } lgr: Liste -> Nat { longueur } preconditions l:Liste pre(tete(l)) = ~ vide(l) pre(supt(l)) = ~ vide(l) axiomes l:Liste; x:S (l1) vide(listenouv) = vrai (l2) lgr(listenouv) = 0 (l3) vide(adjt(l,x)) = faux (l4) lgr(adjt(l,x)) = lgr(l) + 1 (l5) tete(adjt(l,x)) = x (l6) supt(adjt(l,x)) = l fspec Licence informatique Introduction à l’algorithmique. G. Hains

9 spec LISTE1 {Extension de LISTE0 avec de nouvelles operations}
etend LISTE0 {On suppose une operations d'egalite == sur S} operations app: Liste S -> Bool { appartenance } _[_]: Liste Nat -> S { l[i]= i-eme element de l } queue: Liste -> S { element de queue } adjq: Liste S -> Liste { adjoindre a la queue } conc: Liste Liste -> Liste { concatenation } supq: Liste -> Liste { supprimer la queue } preconditions l:Liste; x:S; i:Nat pre(l[i]) = < i /\ i <= lgr(l) pre(queue(l)) = ~ vide(l) pre(supq(l)) = ~ vide(l) axiomes (l7) app(listenouv,x) = faux (l8) app(adjt(l,y),x) = x==y \/ app(l,x) (l9) l[1] = tete(l) (l10) adjt(l,x)[succ(i)] = l[i] (l11) queue(l) = l[lgr(l)] (l12) adjq(listenouv,x) = adjt(listenouv,x) (l13) adjq(adjt(l,y),x) = adjt(adjq(l,x),y) { ... a completer: definition de concaténation ... } fspec Licence informatique Introduction à l’algorithmique. G. Hains