Compare revisions

* A. Boyer

* M. Corboz

* M. Divià

* Y. El Hakouni

* A. Escribano

* P. Kunzli

* G. Legouic

* G. Marino Jarrin

* H. Radhwan

* I. Saroukhanian

* C. Volta

*.pdf

*.json

*.err

*.markdown

*.html

index.md

.puppeteer.json

# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf

docker: docker-compose.yml

	docker-compose run slides

	docker compose run slides

docker_clean: docker-compose.yml

	docker-compose run slides clean

	docker compose run slides clean

puppeteer:

	@echo "Setting chromium to $(CHROMIUM) for puppeteer"

	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

	# @echo "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

index.md: gen_index.sh

	$(shell ./gen_index.sh)

---

title: "Introduction aux algorithmes"

date: "2023-09-19"

title: "Introduction aux algorithmes I"

date: "2025-09-16"

---

# Qu'est-ce qu'un algorithme?

```C

booléen est_premier(nombre) // fonction

    soit i = 2;       // variable, type, assignation

    soit i = 2       // variable, type, assignation

    tant que i < nombre // boucle

        si nombre modulo i == 0 // expression typée

            retourne faux    // expression typée

---

title: "Introduction générale"

date: "2023-09-19"

date: "2025-09-16"

---

# La hotline

Orestis Malaspinas     orestis.malaspinas@hesge.ch       A401

--------------------   ------------------------------    --------------------

* Utilisez le libre service (l'horaire sera fixé prochainement).

* On va intensivement utiliser *Element*, installez le et utilisez le!

* Espace de discussion [Matrix](https://matrix.to/#/!aKYVlcclmPGYXQFxAK:matrix.org?via=matrix.org), installez [element.io](https://element.io).

- Utilisez le libre service (l'horaire sera fixé prochainement).

- On va intensivement utiliser *Element*, installez le et utilisez le!

- Espace de discussion Matrix: <https://rb.gy/ku5es>, installez [element.io](https://element.io).

    ![](figs/matrix_qr.png){width=20%}

* Communauté lemmy: <https://lemmy.hepiapp.ch/c/algo>

# Cyberlearn

- Algorithmes et structures de données

  - <https://cyberlearn.hes-so.ch/course/view.php?id=7276>

  - Clé d'inscription: algo_2023_24

  - Clé d'inscription: algo_2025_26

- Programmation Sequentielle en C

- Programmation séquentielle en C

  - <https://cyberlearn.hes-so.ch/course/view.php?id=7282>

  - Clé d'inscription: prog_seq_2023_24

  - Clé d'inscription: prog_seq_2025_26

# Organisation du module

* Cinq cours, 20% chacun.

## Cinq cours, 20% chacun.

1. Algorithmes et structures de données (2 semestres):

    * 1er semestre:

        * bases de programmation en C jusqu'à Noël.

        * bases de programmation en C jusqu'à Noël,

        * algorithmique jusqu'à fin janvier.

    * 2e semestre:

    * 2ème semestre:

        * algorithmique.

    * Deux évaluations écrites par semestre (1er: novembre et janvier).

    * Deux évaluations écrites par semestre (1er sem.: novembre et janvier).

2. Programmation séquentielle en C (2 semestres)

    * Familiarisation avec l'environnement Linux.

    * Travaux pratiques en C.

    * Apprentissage du gestionnaire de versions: git.

    * Plusieurs exercices illustrant les concepts d'algorithmique.

    * Évaluations (4 tests machine).

3. Programmation système

3. Programmation système (semestre de printemps)

---

subtitle: "Algorithmique et structures de données, 2023-2024"

subtitle: "Algorithmique et structures de données, 2025-2026"

author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"

institute: En partie inspirés des supports de cours de P. Albuquerque

institute: En partie inspiré des supports de cours de P. Albuquerque

lang: fr-CH

revealjs-url: /reveal.js

mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"

*.pdf

*.err

*.markdown

*.html

index.md

.puppeteer.json

PDFOPTIONS = -t beamer

# PDFOPTIONS += -F pantable

PDFOPTIONS += -F mermaid-filter

PDFOPTIONS += --highlight-style my_highlight.theme

PDFOPTIONS += --pdf-engine xelatex

PDFOPTIONS += -V theme:metropolis

PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot

PDFOPTIONS += -V fontsize=smaller

PDFOPTIONS += -V urlcolor=blue

MD=$(wildcard *.md) # Tous les fichiers .md

PDF=$(MD:%.md=%.pdf) # Pour les fichier pdf on transforme .md -> .pdf

HTML=$(MD:%.md=%.html) # Pour les fichier html on transforme .md -> .html

MARKDOWN=$(MD:%.md=%.markdown) # Pour les fichier markdown on transforme .md -> .markdown

CHROMIUM:=$(shell which chromium || which chromium-browser)

all: puppeteer $(PDF) 

# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf

docker: docker-compose.yml

	docker-compose run slides

docker_clean: docker-compose.yml

	docker-compose run slides clean

puppeteer:

	@echo "Setting chromium to $(CHROMIUM) for puppeteer"

	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json

index.md: gen_index.sh

	$(shell ./gen_index.sh)

index.html: index.md

	pandoc -s $(OPTIONS) --css ../css/tufte-css/tufte.css -o $@ $^

markdown: $(MARKDOWN) # La markdown les cibles %.markdown

%.pdf: %.md metadata.yaml # %.pdf (chaque fichier %.md génère un fichier avec le même nom mais l'extension .pdf et la dépendance metadata.yaml)

	pandoc -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^

%.markdown: %.md metadata.yaml yq

	sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header

	grep -v -F -x -f  no_header $< > header.yaml

	echo "---" > tmp.yaml

	./yq_linux_amd64 merge metadata.yaml header.yaml >> tmp.yaml

	cat tmp.yaml no_header > $@

	rm no_header header.yaml tmp.yaml

yq: # On peut même télécharger un petit programme avec notre makefile

	wget -nc https://github.com/mikefarah/yq/releases/download/3.4.1/yq_linux_amd64

	chmod "u+x" yq_linux_amd64 

deploy: all index.html

	mkdir -p algo_cours

	cp *.pdf algo_cours

	cp index.html algo_cours

clean:

	rm -rf *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json algo_cours *.err

.PHONY:	clean index.md puppeteer yq

---

title: "Introduction aux algorithmes"

date: "2023-09-19"

---

# Qu'est-ce qu'un algorithme?

## Définition informelle (recette)

* des entrées (les ingrédients, le matériel utilisé) ;

* des instructions élémentaires simples (frire, flamber, etc.), dont les 

  exécutions dans un ordre précis amènent au résultat voulu ;

* un résultat : le plat préparé.

. . .

## Histoire et étymologie

- Existent depuis 4500 ans au moins (algorithme de division, crible 

  d'Eratosthène).

- Le mot algorithme est dérivé du nom du mathématicien perse

    *Muḥammad ibn Musā al-Khwārizmī*, qui a été "latinisé" comme 

    *Algoritmi*.

. . .

## Définition formelle

En partant d'un état initial et d'entrées (peut-être vides), une séquence finie 

d'instruction bien définies (ordonnées) implémentables sur un ordinateur, afin 

de résoudre typiquement une classe de problèmes ou effectuer un calcul.

# Notions de base d'algorithmique

## Variable

. . .

* Paire: identifiant - valeur (assignation);

## Séquence d'instructions / expressions

. . .

* Opérateurs (arithmétiques / booléens)

* Boucles;

* Structures de contrôle;

* Fonctions;

# Algorithme de vérification qu'un nombre est premier (1/3)

Nombre premier: nombre possédant deux diviseurs entiers distincts.

. . .

## Algorithme naïf (problème)

```C

booléen est_premier(nombre) 

    si 

        pour tout i, t.q. 1 < i < nombre 

            i ne divise pas nombre

    alors vrai

    sinon faux

```

. . .

## Pas vraiment un algorithme: pas une séquence ordonnée et bien définie

. . .

## Problème: Comment écrire ça sous une forme algorithmique?

# Algorithme de vérification qu'un nombre est premier (2/3)

## Algorithme naïf (une solution)

```C

booléen est_premier(nombre) // fonction

    soit i = 2       // variable, type, assignation

    tant que i < nombre // boucle

        si nombre modulo i == 0 // expression typée

            retourne faux    // expression typée

        i = i + 1

    retourne vrai // expression typée

```

# Algorithme de vérification qu'un nombre est premier (3/3)

## Algorithme naïf (une solution en C)

```C

bool est_premier(int nombre) {

    int i; // i est un entier

    i = 2; // assignation i à 2

    while (i < nombre) { // boucle avec condition

        if (0 == nombre % i) { // is i divise nombre

            return false; // i n'est pas premier

        }

        i = i + 1; // sinon on incrémente i

    }

    return true;

}

```

. . .

## Exercice: Comment faire plus rapide?

# Génération d'un exécutable

- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).

- Pour un code `prog.c` la compilation "minimale" est

    ```bash

    $ gcc prog.c

    $ ./a.out # exécutable par défaut

    ```

- Il existe une multitude d'options de compilation:

    ```console

    $ gcc -O1 -std=c11 -Wall -Wextra -g prog.c -o prog 

    	-fsanitize=address 

    ```

    1. `-std=c11` utilisation de C11.

    2. `-Wall et -Wextra` activation des warnings.

    3. `-fsanitize=…`  contrôles d’erreurs à l’exécution (coût en performance).

    4. `-g` symboles de débogages sont gardés.

    5. `-o` défini le fichier exécutable à produire en sortie.

    6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation

# La simplicité de C?

## 32 mots-clé et c'est tout

---------------- -------------- ---------------- ---------------

`auto`{.C}       `double`{.C}   `int`{.C}        `struct`{.C}   

`break`{.C}      `else`{.C}     `long`{.C}       `switch`{.C}   

`case`{.C}       `enum`{.C}     `register`{.C}   `typedef`{.C}  

`char`{.C}       `extern`{.C}   `return`{.C}     `union`{.C}    

`const`{.C}      `float`{.C}    `short`{.C}      `unsigned`{.C} 

`continue`{.C}   `for`{.C}      `signed`{.C}     `void`{.C}

`default`{.C}    `goto`{.C}     `sizeof`{.C}     `volatile`{.C}

`do`{.C}         `if`{.C}       `static`{.C}     `while`{.C}

---------------- -------------- ---------------- ---------------

# Déclaration et typage

En C lorsqu'on veut utiliser une variable (ou une constante), on doit déclarer son type

```C

const double two = 2.0; // déclaration et init.

int x;   // déclaration (instruction)

char c;  // déclaration (instruction)

x = 1;   // affectation (expression)

c = 'a'; // affectation (expression)

int y = x; // déclaration et initialisation en même temps

int a, b, c; // déclarations multiples

a = b = c = 1; // init. multiples

```

# Les variables (1/2)

## Variables et portée

- Une variable est un identifiant, qui peut être liée à une valeur (un expression).

- Une variable a une **portée** qui définit où elle est *visible* (où elle peut être accédée).

- La portée est **globale** ou **locale**.

- Une variable est **globale** est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.

- Une variable est **locale** lorsqu'elle est déclarée dans un **bloc**, `{...}`{.C}.

- Une variable est dans la portée **après** avoir été déclarée.

# Les variables (2/2)

## Exemple 

```C

float max; // variable globale accessible partout

int foo() {

    // max est visible ici

    float a = max; // valide

    // par contre les varibles du main() ne sont pas visibles

}

int main() {

    // max est visible ici

    int x = 1; // x est locale à main

    {

        // x est visible ici, y pas encore

        // on peut par exemple pas faire x = y;

        int y = 2;

    } // y est détruite à la sortie du bloc

} // x est à la sortie de main

```

<!-- TODO: quiz, compile, compile pas -->

<!-- ```C

int main() {

    global = 1;

} // COMPILE PAS

```

```C

int main() {

    int global = 1;

    {

        printf("global = %d", global);

    }

} // COMPILE

```

```C

int local;

int main() {

    local = 1;

    {

        printf("local = %d", local);

    }

} // COMPILE

```

```C

#include <stdio.h>

int local = 0;

int main() {

    int local = -1;

    {

        int local = 1;

        printf("local = %d\n", local);

    }

} // COMPILE

``` -->

# Quiz: compile ou compile pas?

## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501934)

# Types de base (1/4)

## Numériques

Type                               Signification (**gcc pour x86-64**)            

---------------------------------- ---------------------------------------------

`char`{.C}, `unsigned char`{.C}    Entier signé/non-signé 8-bit

`short`{.C}, `unsigned short`{.C}  Entier signé/non-signé 16-bit

`int`{.C}, `unsigned int`{.C}      Entier signé/non-signé 32-bit

`long`{.C}, `unsigned long`{.C}    Entier signé/non-signé 64-bit

`float`{.C}                        Nombre à virgule flottante, simple précision

`double`{.C}                       Nombre à virgule flottante, double précision

---------------------------------- ---------------------------------------------

**La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.**

# Types de base (2/4)

Voir `<stdint.h>` pour des représentations **portables**

Type                               Signification

---------------------------------- ---------------------------------------------

`int8_t`{.C}, `uint8_t`{.C}        Entier signé/non-signé 8-bit

`int16_t`{.C}, `uint16_t`{.C}      Entier signé/non-signé 16-bit

`int32_t`{.C}, `uint32_t`{.C}      Entier signé/non-signé 32-bit

`int64_t`{.C}, `uint64_t`{.C}      Entier signé/non-signé 64-bit

---------------------------------- ---------------------------------------------

. . .

## Prenez l'habitude d'utiliser ces types-là!

# Types de base (3/4)

## Booléens

- Le ANSI C n'offre pas de booléens.

- L'entier `0`{.C} signifie *faux*, tout le reste *vrai*.

- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.

- En réalité c'est un entier:

  - $1 \Rightarrow$ `true`{.C}

  - $0 \Rightarrow$ `false`{.C}

- On peut les manipuler comme des entier (les sommer, les multiplier, ...).

# Quiz: booléens

## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501922)

<!-- TODO Quiz en ligne -->

<!-- ```C

if (42) { /* vrai */ }

int x = 100;

if (x == 4) { /* faux */ }

if (x) { /* vrai */ }

int x = 100;

while (x−−) { /* répète tant que x est différent de 0 */ }

if (0) { /* faux */ }

if (i = 4) { /* vrai */ }

if (i = 0) { /* faux */ }

#include <stdbool.h>

bool x = true;

if (x) { /* vrai */ }

``` -->

# Types de base (4/4)

## Conversions

- Les conversions se font de manière:

  - Explicite:

    ```C

    int a = (int)2.8;

    double b = (double)a;

    int c = (int)(2.8+0.5);

    ```

  - Implicite:

    ```C

    int a = 2.8; // warning, si activés, avec clang

    double b = a + 0.5;

    char c = b; // pas de warning...

    int d = 'c';

    ```

# Quiz: conversions

## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501925)

<!-- TODO Quiz en ligne -->

<!-- ```C

int a = (int)2.8; // 2

double b = 2.85;

int c = b + 0.5; // 3

int d = a + 0.5; // 2

bool d = 2.78; // 1

bool e = 1.0; // 1

``` -->

---

title: "Piles"

date: "2023-12-05"

---

# Rappel

## Qu'est-ce qu'une pile?

. . .

* Structure de données LIFO.

## Quelles fonctionnalités?

. . .

1. Empiler (push): ajouter un élément sur la pile.

2. Dépiler (pop): retirer l'élément du sommet de la pile et le retrouner.

3. Liste vide? (is_empty?).

4. Jeter un oeil (peek): retourner l'élément du sommet de la pile (sans le dépiler).

5. Nombre d'éléments (length).

# Structure de données (1/2)

## Struct `stack`

. . .

```C

#define MAX_CAPACITY 500

typedef struct _stack {

    int data[MAX_CAPACITY]; // les données

    int top;                // indice du sommet

} stack;

```

# Structure de données (2/2)

## Fonctions `stack`

. . .

```C

void stack_init(stack *s) {

    s->top = -1;

}

bool stack_is_empty(stack s) {

    return s.top == -1;

} 

void stack_push(stack *s, int val) {

    s->top += 1;

    s->data[s->top] = val;

}

int stack_pop(stack *s) {

    s->top -= 1;

    return s->data[s->top+1];

}

```

# La pile dynamique

## Comment modifier le code précédent pour avoir une taille dynamique?

. . .

```C

// alloue une zone mémoire de size octets

void *malloc(size_t size); 

// change la taille allouée à size octets (contiguïté garantie)

void *realloc(void *ptr, size_t size);

```

. . .

**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).

## Et maintenant?

. . .

```C

void stack_create(stack *s); // crée une pile avec une taille par défaut

// vérifie si la pile est pleine et réalloue si besoin

void stack_push(stack *s, int val);

// vérifie si la pile est vide/trop grande 

// et réalloue si besoin

void stack_pop(stack *s, int *ret); 

```

. . .

## Faisons l'implémentation ensemble

# Le tri à deux piles (1/3)

## Cas pratique

![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}

# Le tri à deux piles (2/3)

## Exercice: formaliser l'algorithme

. . .

## Algorithme de tri nécessitant 2 piles (G, D)

Soit `tab` le tableau à trier:

```C

pour i de 0 à N-1

    tant que (tab[i] > que le sommet de G)

        dépiler G dans D

    tant que (tab[i] < que le sommet de D)

        dépiler de D dans G

    empiler tab[i] sur G

dépiler tout D dans G

tab est trié dans G

```

# Le tri à deux piles (3/3)

## Exercice: trier le tableau `[2, 10, 5, 20, 15]`

```C

```

# La calculatrice (1/8)

## Vocabulaire

```C

2 + 3 = 2 3 +,

```

`2` et `3` sont les *opérandes*, `+` l'*opérateur*.

. . .

## La notation infixe

```C

2 * (3 + 2) - 4 = 6.

```

## La notation postfixe

```C

2 3 2 + * 4 - = 6.

```

## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`

. . .

```C

2 3 4 * * 2 + = (2 * (3 * 4)) + 2.

```

# La calculatrice (2/8)

## De infixe à post-fixe

* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.

* Les opérateurs on des *priorités* différentes.

```C

^   : priorité 3

* / : priorité 2

+ - : priorité 1

( ) : priorité 0 // pas un opérateur mais bon

```

# La calculatrice (3/8)

## De infixe à post-fixe: algorithme

* On lit l'expression infixe de gauche à droite.

* On examine le prochain caractère de l'expression infixe.

    * Si opérande, le placer dans l'expression du résultat.

    * Si parenthèse le mettre dans la pile (priorité 0).

    * Si opérateur, comparer sa priorité avec celui du sommet de la pile:

        * Si sa priorité est plus élevée, empiler.

        * Sinon dépiler l'opérateur de la pile dans l'expression du résultat et

          recommencer jusqu'à apparition d'un opérateur de priorité plus faible

          au sommet de la pile (ou pile vide).

    * Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les

      placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse

      ouverte apparaisse au sommet, dépiler également la parenthèse.

    * Si il n'y a pas de caractère dans l'expression dépiler tous les

      opérateurs dans le résultat.

# La calculatrice (4/8)

## De infixe à post-fixe: exemple

```C

Infixe              Postfixe            Pile    Priorité

((A*B)/D-F)/(G+H)   Vide                Vide    Néant

 (A*B)/D-F)/(G+H)   Vide                (       0

  A*B)/D-F)/(G+H)   Vide                ((      0

   *B)/D-F)/(G+H)   A                   ((      0

    B)/D-F)/(G+H)   A                   ((*     2

     )/D-F)/(G+H)   AB                  ((*     2

      /D-F)/(G+H)   AB*                 (       0

       D-F)/(G+H)   AB*                 (/      2

        -F)/(G+H)   AB*D                (/      2

         F)/(G+H)   AB*D/               (-      1

          )/(G+H)   AB*D/F              (-      1

           /(G+H)   AB*D/F-             Vide    Néant

```

# La calculatrice (5/8)

## De infixe à post-fixe: exemple

```C

Infixe              Postfixe            Pile    Priorité

((A*B)/D-F)/(G+H)   Vide                Vide    Néant

--------------------------------------------------------

           /(G+H)   AB*D/F-             Vide    Néant

            (G+H)   AB*D/F-             /       2

             G+H)   AB*D/F-             /(      0

              +H)   AB*D/F-G            /(      0

               H)   AB*D/F-G            /(+     1

                )   AB*D/F-GH           /(+     1

             Vide   AB*D/F-GH+          /       2

             Vide   AB*D/F-GH+/         Vide    Néant

```

# La calculatrice (6/8)

\footnotesize

## Exercice: écrire le code et le poster sur matrix

* Quelle est la signature de la fonction?

. . .

* Une sorte de corrigé:

```C

char *infix_to_postfix(char* infix) { // init and alloc stack and postfix

    for (size_t i = 0; i < strlen(infix); ++i) {

        if (is_operand(infix[i])) { 

            // we just add operands in the new postfix string

        } else if (infix[i] == '(') { 

            // we push opening parenthesis into the stack

        } else if (infix[i] == ')') { 

            // we pop everything into the postfix

        } else if (is_operator(infix[i])) {

            // this is an operator. We add it to the postfix based 

            // on the priority of what is already in the stack and push it

        }    

    } 

    // pop all the operators from the s at the end of postfix

    // and end the postfix with `\0`

    return postfix;

} 

```

# La calculatrice (7/8)

## Évaluation d'expression postfixe: algorithme

* Chaque *opérateur* porte sur les deux opérandes qui le précèdent.

* Le *résultat d'une opération* est un nouvel *opérande* qui est remis au

  sommet de la pile.

## Exemple

```C

2 3 4 + * 5 - = ?

```

* On parcours de gauche à droite:

```C

Caractère lu        Pile opérandes

    2               2

    3               2, 3

    4               2, 3, 4

    +               2, (3 + 4)

    *               2 * 7

    5               14, 5

    -               14 - 5 = 9

```

# La calculatrice (8/8)

## Évaluation d'expression postfixe: algorithme

1. La valeur d'un opérande est *toujours* empilée.

2. L'opérateur s'applique *toujours* au 2 opérandes au sommet.

3. Le résultat est remis au sommet.

## Exercice: écrire l'algorithme en C (et poster sur matrix)

. . .

```C

bool evaluate(char *postfix, double *val) { // init stack

    for (size_t i = 0; i < strlen(postfix); ++i) {

        if (is_operand(postfix[i])) {

            stack_push(&s, postfix[i]);

        } else if (is_operator(postfix[i])) {

            double rhs = stack_pop(&s);

            double lhs = stack_pop(&s);

            stack_push(&s, op(postfix[i], lhs, rhs));

        }    

    }

    return stack_pop(&s);

}

```

---

title: "Calculatrices, liste chaînée, et files d'attente"