licence informatique 2006-2007. introduction à lalgorithmique. g. hains piles, files et listes:...
TRANSCRIPT
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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 2006-2007. Introduction à l’algorithmique. G. Hains
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 2006-2007. Introduction à l’algorithmique. G. Hains
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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
Licence informatique 2006-2007. Introduction à l’algorithmique. G. Hains
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