ajout du CM du 25/09

CM SDA L2A.txt

@@ -183,6 +183,8 @@ if (precondition-insertion(e, x)){
 }
 else printf("insertion : préconditions non satisfaite");
 
+
+
 Cours magistrale du 18/09/2024.
 
 
@@ -242,4 +244,213 @@ Je définis un objet générique de sorte S : SPEC TRIV étend BASE
                                            sorte S
                                            fspec
 Supposons qu'on souhaite spécifier des piles bornées => il suffit d'ajouter une pré-conditions
-à empiler : pré empiler(p, x) = hauteur(p) < N 
\ No newline at end of file
+à empiler : pré empiler(p, x) = hauteur(p) < N 
+
+
+
+Cours magistrale du 25/09/2024
+
+1.2 Implantation contiguë et programmation fonctionnelle
+
+   ________________________________
+  |            ______ ___          |
+  |   |7|2|5|2|______|___|   h|4|  |    le sommet est dans l'indice h-1
+  |    0 1 2 3        N-1          |
+  |________________________________|
+
+Pour le tableau, on travaille sur un tableau statique.
+(On pouvait le faire aussi avec un tableau dynamique et une programmation par mutation)
+
+#define N 100
+typedef struct { S v[N]; Nat h;} Pile;
+
+Pile pilenouv(){
+  Pile p;
+  p.h = 0;
+  return p;
+}
+
+Pile empiler(Pile p, S x){ //piles bornées par empiler(p) = hauteur(p)<N
+  p.v[p.h] = x;
+  p.h++;
+  return p;
+}
+
+Pile depiler(Pile p){ //pre !vide(p)
+  p.h--;
+  return p;
+}
+
+S sommet(Pile p){
+  return p.v[p.h-1];
+}
+
+Bool vide(Pile p){
+  return p.h == 0;
+}
+
+Nat hauteur(Pile p){
+  return p.h;
+}
+
+1.3 Implantation contiguë et programmation par mutation 
+
+typedef struct strpile {S v[N]; Nat h;} Strpile, * Pile;
+
+Pile pilenouv(){ //allocation dynamique
+  Pile p = MALLOC(Strpile);
+  p->h = 0; //toutes les autres op remplacer . par ->
+  return p;
+} 
+Pile empiler(Pile p, S x){
+  p->v[p->h] = x;
+  p->h++;
+  return p;
+}
+
+Pile depiler(Pile p){
+  p->h--;
+  return p;
+}
+
+Pile remplacer(Pile p, S x){
+  p->v[p->h-1] = x;
+  return p;
+}
+
+1.4 Implantation contiguë et programmation avec mutation
+
+Pour des piles non bornées, la solution consiste à utiliser un tableau dynamique.
+
+#define TAILLE 100
+typedef struct{ S * v; Nat h; Nat taille;}Pile;
+
+Pile pilenouv(){                  p __________________
+  Pile p;                          | |v| |h| |taille| |
+  p.v = MALLOC N(S, TAILLE);       |__________________|
+  p.h=0;
+  p.taille = TAILLE;
+  return p;
+}
+
+Pile empiler(Pile p, S x){
+  if (p.h == p.taille){
+    S * save = p.v;
+    p.v = MALLOC N(p.v, S p.taille + TAILLE);
+    if (p.v == NULL){
+      p.v = save;
+      printf("message d'erreur.\n");
+    } else {
+      p.taille += TAILLE;
+      p.v[p.h] = x;
+      p.h++;
+    }
+  } else {
+    p.v[p.h] = x;
+    p.h++;
+  }
+  return p;
+}
+
+1.4 Implemantation par chaînage
+                                                                                       ______
+Une pile peut être implantée comme une liste chainée = suite de cellules à 2 places   |valeur| la première: la valeur de l'élément de la pile
+                                                                                      |------|
+                                                                                      |__°---|-> la deuxième un pointeur vers la cellule suivante
+Ainsi, la pile est le pointeur vers la 1ère cellule 
+
+Pile p ___    ___    ___    ___    ____
+      | °-|->| 2 |  | 5 |  | 2 |  | 17 |
+      |___|  |---|  |---|  |---|  |----|
+             |_°-|->|_°-|->|_°-|->|NULL|
+             Sommet       Strpile
+
+Typedef struct strpile{S valeur; struct strpile * sommet}Strpile, * Pile;
+
+à noter que le sommet de la pile sera placé à la 1ère cellule de la liste.
+
+                                      ____ (2)
+Pile pilenouv(){             ____    | x  |
+  Pile p = NULL;       Pile |NULL|   |----|   __
+  return p;                 |____|   |NULL|  |p1| (1)
+}
+
+Pile empiler(Pile p, S x){               __
+  Pile p1 = MALLOC (Strpile);           |  |
+  p1 -> valeur = x;                     |__| 
+  p1 -> suivant;                        
+  return p1;                            
+}
+
+Pile depiler(Pile p){return p -> suivant;} //!vide(p)
+
+Incroyable, en ne liberant pas la mémoire, 
+on conserve toutes les piles en partageant les cellules mémoires
+-> prog fonctionnelle par chaînage.
+
+S sommet (Pile p){return p->valeur;} //!vide(p)
+
+Pile remplacer(Pile p, S x){return empiler(depiler(p), x);} //!vide(p)
+
+Nat hauteur(Pile p){return vide(p) ? 0 : hauteur(p -> suivant)+1;} //récursive
+
+Nat hauteur(Pile p){
+  for (Nat h = 0; !vide(p); h++; p = p -> suivant); //itérative
+  return h;
+}
+
+Pour une prog par mutation des piles, il faut désallouer les cellules des éléments.
+
+Pile depiler(Pile p){ //!vide(p)
+  Pile p1 = p -> suivant;
+  FREE(p);
+  return p1;
+}
+
+Pour être + efficace, on modifie
+
+Pile remplacer(Pile p, S y){ //!vide(p)
+  p -> valeur = y;
+  return p;
+}
+
+variante de structures de données chainées des piles
+  -par exemple, en stockant la hauteur                     ______    ___    ___    ___    ____
+                                                          | |•|--|->| 1 |  | 4 |  | 7 |  | 24 |
+                                                          |      |  |---|  |---|  |---|  |----|
+                                                          | |h=4||  | •-|->| •-|->| •-|->|NULL|
+                                                          |______|  |___|  |___|  |___|  |____|
+                                                          Pile p
+
+typedef struct strpile{S valeur; struct strpile * suivant;} Strpile;
+typedef struct {Nat hauteur; Strpile * sommet;} Pile;
+(ou)
+typedef struct {Nat hauteur; Strpile * sommet;} * Pile;
+
+exercice : réécrire les opérations avec cette SD
+
+Pile pilenouv(){ //1
+  Pile p;
+  p.hauteur = 0;
+  p.sommet = NULL;
+  return p;
+}
+
+Pile pilenouv(){ //2
+  Pile p = MALLOC(Strpile);
+  p -> sommet = NULL;
+  return p;
+}
+
+Pile empiler(Pile p, S x){ //1
+  Srtpile * new = MALLOC(Strpile); (1)
+  new -> valeur = x;          |
+  new -> suivant = p.sommet;  | (2)
+  p.hauteur = p.hauteur + 1; |
+  p.sommet = new;            |(3)
+  return p;
+}
+
+1. Dessiner avec les actions dans l'ordre.
+2. Traduire le dessin en instructions.
+3. Verification.
\ No newline at end of file