licence informatique 2006-2007. introduction à lalgorithmique. g. hains piles, files et listes:...

Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains

Piles, files et listes: notions théoriques

Propriétés des structures linéairesApplications de chaque structure de donnéesSpécifications algébriques


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.

Propriétés des structures 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).

Applications des structures de données linéaires


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.

Spécifications algébriques


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))


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


spec FILE0 {Files generiques de taille non-bornee}etend BOOL0, NAT0sorte 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) fsifspec


spec LISTE0 {Listes generiques de taille non-bornee}etend BOOL0, NAT0sorte 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)) = lfspec


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]) = 0 < 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 2006-2007. introduction à lalgorithmique. g. hains piles, files et listes:...

Documents