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

Licence informatique 2006-2007. Introduction à lalgorithmique. G. Hains Piles, files et listes: notions théoriques Propriétés des structures linéaires.

Présentations similaires


Présentation au sujet: "Licence informatique 2006-2007. Introduction à lalgorithmique. G. Hains Piles, files et listes: notions théoriques Propriétés des structures linéaires."— Transcription de la présentation:

1 Licence informatique Introduction à lalgorithmique. G. Hains 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

2 Licence informatique Introduction à lalgorithmique. 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 naccède à une valeur quà travers les précédentes ou les suivantes. Insertion et effacement en un nombre constant dopérations, mais laccès prend plusieurs opérations. Pour un tableau ce serait le contraire. Piles: structures linéaires quon naccè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 cest-à-dire dernier arrivé premier sorti, ce qui décrit le protocole dinsertion/effacement. File: structures linéaires quon accède par les deux extrémités mais une sert à linsertion alors que lautre sert à leffacement uniquement. On appelle parfois les files les structures FIFO ou First-in First-out cest-à-dire premier arrivé premier sorti, ce qui décrit le protocole dinsertion/effacement. Propriétés des structures linéaires

3 Licence informatique Introduction à lalgorithmique. 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 quun ordre existe entre les éléments. Les langages de programmation déclarative (de très haut niveau) sen 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 dun graphe (le fil dAriane est une pile), parcours dun arbre, exécution des blocs dun programme et des appels de fonctions, compilation dun arbre syntaxique en langage cible etc. Files: On utilise une file quand il faut simuler une file dattente et/ou conserver à la sortie lordre des éléments insérés à lentrée: canal de communication, lecture/écriture dun 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

4 Licence informatique Introduction à lalgorithmique. 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

5 Licence informatique Introduction à lalgorithmique. 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))

6 Licence informatique Introduction à lalgorithmique. 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

7 Licence informatique Introduction à lalgorithmique. G. Hains 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

8 Licence informatique Introduction à lalgorithmique. G. Hains 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

9 Licence informatique Introduction à lalgorithmique. 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


Télécharger ppt "Licence informatique 2006-2007. Introduction à lalgorithmique. G. Hains Piles, files et listes: notions théoriques Propriétés des structures linéaires."

Présentations similaires


Annonces Google