3727c589eeac4e42774fec9991e6ca7babc473d5 to main · algorithmique / cours

Some changes are not shown.

For a faster browsing experience, only 39 of 688 files are shown. Download one of the files below to see all changes.

README.md0 → 100644

+17
−0

Original line number
Diff line number
Diff line

# Remerciements et contributions

Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique):

* P. Albuquerque

* J. Bach

* A. Boyer

* M. Corboz

* M. Divià

* Y. El Hakouni

* A. Escribano

* P. Kunzli

* G. Legouic

* G. Marino Jarrin

* H. Radhwan

* I. Saroukhanian

* C. Volta

slides/.gitignore

+1
−4

Original line number
Diff line number
Diff line

*.pdf

*.json

*.err

*.markdown

*.html

index.md

.puppeteer.json

slides/Makefile

+4
−16

Original line number
Diff line number
Diff line

PDFOPTIONS = -t beamer

# PDFOPTIONS += -F pantable

# PDFOPTIONS += -F mermaid-filter

PDFOPTIONS += -F mermaid-filter

PDFOPTIONS += --highlight-style my_highlight.theme

PDFOPTIONS += --pdf-engine xelatex

PDFOPTIONS += -V theme:metropolis

@@ -8,15 +8,6 @@ PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot

PDFOPTIONS += -V fontsize=smaller

PDFOPTIONS += -V urlcolor=blue

REVEALOPTIONS = -t revealjs

REVEALOPTIONS += -F mermaid-filter

REVEALOPTIONS += --self-contained

REVEALOPTIONS += -V revealjs-url=reveal.js

REVEALOPTIONS += -V theme=white

REVEALOPTIONS += -V width=1920

REVEALOPTIONS += -V margin=0

REVEALOPTIONS += --slide-level=1

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

@@ -27,15 +18,15 @@ 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 make puppeteer -k || true

	docker-compose run slides make all -k || true

	docker compose run slides

docker_clean: docker-compose.yml

	docker-compose run slides make clean -k || true

	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)

@@ -48,9 +39,6 @@ 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 $@ $^

%.html: %.md metadata.yaml

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

%.markdown: %.md metadata.yaml yq

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

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

slides/cours_1.md

+10
−219

Original line number
Diff line number
Diff line

---

title: "Introduction aux algorithmes"

date: "2022-09-21"

title: "Introduction aux algorithmes I"

date: "2025-09-16"

---

# Qu'est-ce qu'un algorithme?

@@ -42,7 +42,7 @@ de résoudre typiquement une classe de problèmes ou effectuer un calcul.

. . .

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

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

* Boucles;

* Structures de contrôle;

* Fonctions;

@@ -79,7 +79,7 @@ booléen est_premier(nombre)

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

@@ -99,7 +99,7 @@ bool est_premier(int nombre) {

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

            return false; // i n'est pas premier

        }

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

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

    }

    return true;

}

@@ -121,8 +121,8 @@ bool est_premier(int nombre) {

- Il existe une multitude d'options de compilation:

    ```bash

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

    ```console

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

    	-fsanitize=address 

    ```

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

@@ -240,7 +240,7 @@ int main() {

# Quiz: compile ou compile pas?

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

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

# Types de base (1/4)

@@ -288,7 +288,7 @@ Type                               Signification

# Quiz: booléens

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

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

<!-- TODO Quiz en ligne -->

<!-- ```C

@@ -332,7 +332,7 @@ if (x) { /* vrai */ }

# Quiz: conversions

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

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

<!-- TODO Quiz en ligne -->

<!-- ```C

@@ -347,212 +347,3 @@ bool d = 2.78; // 1

bool e = 1.0; // 1

``` -->

# Expressions et opérateurs (1/6)

Une expression est tout bout de code qui est **évalué**.

## Expressions simples

- Pas d'opérateurs impliqués.

- Les littéraux, les variables, et les constantes.

```C

const int L = -1; // 'L' est une constante, -1 un littéral

int x = 0;        // '0' est un litéral

int y = x;        // 'x' est une variable

int z = L;        // 'L' est une constante

```

## Expressions complexes

- Obtenues en combinant des *opérandes* avec des *opérateurs*

```C

int x;     // pas une expression (une instruction)

x = 4 + 5; // 4 + 5 est une expression

           // dont le résultat est affecté à 'x'

```

# Expressions et opérateurs (2/6)

## Opérateurs relationnels

Opérateurs testant la relation entre deux *expressions*:

  - `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.

| Opérateur | Syntaxe      | Résultat             |

|-----------|--------------|----------------------|

| `<`{.C}   | `a < b`{.C}  | 1 si a <  b; 0 sinon |

| `>`{.C}   | `a > b`{.C}  | 1 si a >  b; 0 sinon |

| `<=`{.C}  | `a <= b`{.C} | 1 si a <= b; 0 sinon |

| `>=`{.C}  | `a >= b`{.C} | 1 si a >= b; 0 sinon |

| `==`{.C}  | `a == b`{.C} | 1 si a == b; 0 sinon |

| `!=`{.C}  | `a != b`{.C} | 1 si a != b; 0 sinon |

# Expressions et opérateurs (3/6)

## Opérateurs logiques

| Opérateur | Syntaxe      | Signification        |

|-----------|--------------|----------------------|

| `&&`{.C}  | `a && b`{.C} | ET logique           |

| `||`{.C}  | `a || b`{.C} | OU logique           |

| `!`{.C}   | `!a`{.C}     | NON logique          |

# Quiz: opérateurs logiques

## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)

<!-- TODO: Quiz -->

<!-- ```C

1 && 0 == 0

7 && 3 == 1

4 || 3 == 1

!34 == 0

!0 == 1

Soit n un unsigned char initialisé à 127:

!n == 0

``` -->

# Expressions et opérateurs (4/6)

## Opérateurs arithmétiques

| Opérateur | Syntaxe      | Signification        |

|-----------|--------------|----------------------|

| `+`{.C}   | `a + b`{.C}  | Addition             |

| `-`{.C}   | `a - b`{.C}  | Soustraction         |

| `*`{.C}   | `a * b`{.C}  | Multiplication       |

| `/`{.C}   | `a / b`{.C}  | Division             |

| `%`{.C}   | `a % b`{.C}  | Modulo               |

# Expressions et opérateurs (5/6)

## Opérateurs d'assignation

| Opérateur | Syntaxe      | Signification                               |

|-----------|--------------|---------------------------------------------|

| `=`{.C}   | `a = b`{.C}  | Affecte la valeur `b` à la variable `a`     |

|           |              | et retourne la valeur de `b`                |

| `+=`{.C}  | `a += b`{.C} | Additionne la valeur de `b` à `a` et        |

|           |              | assigne le résultat à `a`.                  |

| `-=`{.C}  | `a -= b`{.C} | Soustrait la valeur de `b` à `a` et         |

|           |              | assigne le résultat à `a`.                  |

| `*=`{.C}  | `a *= b`{.C} | Multiplie la valeur de `b` à `a` et         |

|           |              | assigne le résultat à `a`.                  |

| `/=`{.C}  | `a /= b`{.C} | Divise la valeur de `b` à `a` et            |

|           |              | assigne le résultat à `a`.                  |

| `%=`{.C}  | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |

|           |              | assigne le résultat à `a`.                  |

# Expressions et opérateurs (6/6)

## Opérateurs d'assignation (suite)

| Opérateur | Syntaxe      | Signification                               |

|-----------|--------------|---------------------------------------------|

| `++`{.C}  | `++a`{.C}    | Incrémente la valeur de `a` de 1 et         |

|           |              | retourne le résultat (`a += 1`).            |

| `--`{.C}  | `--a`{.C}    | Décrémente la valeur de `a` de 1 et         |

|           |              | retourne le résultat (`a -= 1`).            |

| `++`{.C}  | `a++`{.C}    | Retourne `a`{.C} et incrémente `a` de 1.    |

| `--`{.C}  | `a--`{.C}    | Retourne `a`{.C} et décrémente `a` de 1.    |

# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)

## Syntaxe

```C

if (expression) {

    instructions;

} else if (expression) { // optionnel

                         // il peut y en avoir plusieurs

    instructions;

} else {

    instructions; // optionnel

}

```

```C

if (x) { // si x s'évalue à `vrai`

    printf("x s'évalue à vrai.\n");

} else if (y == 8) { // si y vaut 8

    printf("y vaut 8.\n");

} else {

    printf("Ni l'un ni l'autre.\n");

}

```

# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)

## Pièges

```C

int x, y;

x = y = 3;

if (x = 2)

    printf("x = 2 est vrai.\n");

else if (y < 8)

    printf("y < 8.\n");

else if (y == 3)

    printf("y vaut 3 mais cela ne sera jamais affiché.\n");

else

    printf("Ni l'un ni l'autre.\n");

    x = -1; // toujours évalué

```

# Quiz: `if ... else`{.C}

## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)

# Structures de contrôle: `while`{.C}

## La boucle `while`{.C}

```C

while (condition) {

    instructions;

}

do {

    instructions;

} while (condition);

```

## La boucle `while`{.C}, un exemple

```C

int sum = 0; // syntaxe C99

while (sum < 10) {

    sum += 1;

}

do {

    sum += 10;

} while (sum < 100)

```

# Structures de contrôle: `for`{.C}

## La boucle `for`{.C}

```C

for (expression1; expression2; expression3) {

    instructions;

}

```

## La boucle `for`{.C}

```C

int sum = 0; // syntaxe C99

for (int i = 0; i < 10; i++) {

    sum += i;

}

for (int i = 0; i != 1; i = rand() % 4) { // ésotérique

    printf("C'est plus ésotérique.\n");

}

```

slides/docker-compose.yml0 → 100644

+10
−0

Original line number
Diff line number
Diff line

version: "3.3"

services:

    slides:

        image:  omalaspinas/pandoc:latest

        user: 1000:1000

        container_name: slides

        volumes:

            - ./:/data

        entrypoint: ["make"]

        working_dir: /data

slides/intro.md

+18
−19

Original line number
Diff line number
Diff line

---

title: "Introduction générale"

date: "2022-09-20"

date: "2025-09-16"

---

# La hotline

@@ -11,10 +11,9 @@ Paul Albuquerque       paul.albuquerque@hesge.ch         B410

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%}

@@ -23,31 +22,31 @@ Orestis Malaspinas     orestis.malaspinas@hesge.ch       A401

Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:

- Algorithmes et structures de données

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

  - Clé d'inscription: algo_2021_22

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

  - Clé d'inscription: algo_2025_26

- Programmation Sequentielle en C

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

  - Clé d'inscription: prog_seq_2021_22

- Programmation séquentielle en C

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

  - Clé d'inscription: prog_seq_2025_26

# Organisation du module

* Deux cours, 50% chacun.

1. Algorithmes et structures de données:

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

2. Programmation séquentielle en C

    * 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:

        * Deux évaluations machine (1er semestre).

        * Probablement, une évaluation machine et un projet (2e semestre).

    * Évaluations (4 tests machine).

3. Programmation système (semestre de printemps)

slides/metadata.yaml

+3
−3

Original line number
Diff line number
Diff line

---

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

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

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

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

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

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"

slides_2022/Makefile0 → 100644

+61
−0

Original line number
Diff line number
Diff line

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

slides_2022/cours_1.md0 → 100644

+558
−0

Original line number
Diff line number
Diff line

---

title: "Introduction aux algorithmes"

date: "2022-09-21"

---

# 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 (arthimé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 += 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:

    ```bash

    $ gcc -O1 -std=c11 -Wall -Wextra -g porg.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=1033948)

# 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=1032492)

<!-- 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=1033446)

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

``` -->

# Expressions et opérateurs (1/6)

Une expression est tout bout de code qui est **évalué**.

## Expressions simples

- Pas d'opérateurs impliqués.

- Les littéraux, les variables, et les constantes.

```C

const int L = -1; // 'L' est une constante, -1 un littéral

int x = 0;        // '0' est un litéral

int y = x;        // 'x' est une variable

int z = L;        // 'L' est une constante

```

## Expressions complexes

- Obtenues en combinant des *opérandes* avec des *opérateurs*

```C

int x;     // pas une expression (une instruction)

x = 4 + 5; // 4 + 5 est une expression

           // dont le résultat est affecté à 'x'

```

# Expressions et opérateurs (2/6)

## Opérateurs relationnels

Opérateurs testant la relation entre deux *expressions*:

  - `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.

| Opérateur | Syntaxe      | Résultat             |

|-----------|--------------|----------------------|

| `<`{.C}   | `a < b`{.C}  | 1 si a <  b; 0 sinon |

| `>`{.C}   | `a > b`{.C}  | 1 si a >  b; 0 sinon |

| `<=`{.C}  | `a <= b`{.C} | 1 si a <= b; 0 sinon |

| `>=`{.C}  | `a >= b`{.C} | 1 si a >= b; 0 sinon |

| `==`{.C}  | `a == b`{.C} | 1 si a == b; 0 sinon |

| `!=`{.C}  | `a != b`{.C} | 1 si a != b; 0 sinon |

# Expressions et opérateurs (3/6)

## Opérateurs logiques

| Opérateur | Syntaxe      | Signification        |

|-----------|--------------|----------------------|

| `&&`{.C}  | `a && b`{.C} | ET logique           |

| `||`{.C}  | `a || b`{.C} | OU logique           |

| `!`{.C}   | `!a`{.C}     | NON logique          |

# Quiz: opérateurs logiques

## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)

<!-- TODO: Quiz -->

<!-- ```C

1 && 0 == 0

7 && 3 == 1

4 || 3 == 1

!34 == 0

!0 == 1

Soit n un unsigned char initialisé à 127:

!n == 0

``` -->

# Expressions et opérateurs (4/6)

## Opérateurs arithmétiques

| Opérateur | Syntaxe      | Signification        |

|-----------|--------------|----------------------|

| `+`{.C}   | `a + b`{.C}  | Addition             |

| `-`{.C}   | `a - b`{.C}  | Soustraction         |

| `*`{.C}   | `a * b`{.C}  | Multiplication       |

| `/`{.C}   | `a / b`{.C}  | Division             |

| `%`{.C}   | `a % b`{.C}  | Modulo               |

# Expressions et opérateurs (5/6)

## Opérateurs d'assignation

| Opérateur | Syntaxe      | Signification                               |

|-----------|--------------|---------------------------------------------|

| `=`{.C}   | `a = b`{.C}  | Affecte la valeur `b` à la variable `a`     |

|           |              | et retourne la valeur de `b`                |

| `+=`{.C}  | `a += b`{.C} | Additionne la valeur de `b` à `a` et        |

|           |              | assigne le résultat à `a`.                  |

| `-=`{.C}  | `a -= b`{.C} | Soustrait la valeur de `b` à `a` et         |

|           |              | assigne le résultat à `a`.                  |

| `*=`{.C}  | `a *= b`{.C} | Multiplie la valeur de `b` à `a` et         |

|           |              | assigne le résultat à `a`.                  |

| `/=`{.C}  | `a /= b`{.C} | Divise la valeur de `b` à `a` et            |

|           |              | assigne le résultat à `a`.                  |

| `%=`{.C}  | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |

|           |              | assigne le résultat à `a`.                  |

# Expressions et opérateurs (6/6)

## Opérateurs d'assignation (suite)

| Opérateur | Syntaxe      | Signification                               |

|-----------|--------------|---------------------------------------------|

| `++`{.C}  | `++a`{.C}    | Incrémente la valeur de `a` de 1 et         |

|           |              | retourne le résultat (`a += 1`).            |

| `--`{.C}  | `--a`{.C}    | Décrémente la valeur de `a` de 1 et         |

|           |              | retourne le résultat (`a -= 1`).            |

| `++`{.C}  | `a++`{.C}    | Retourne `a`{.C} et incrémente `a` de 1.    |

| `--`{.C}  | `a--`{.C}    | Retourne `a`{.C} et décrémente `a` de 1.    |

# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)

## Syntaxe

```C

if (expression) {

    instructions;

} else if (expression) { // optionnel

                         // il peut y en avoir plusieurs

    instructions;

} else {

    instructions; // optionnel

}

```

```C

if (x) { // si x s'évalue à `vrai`

    printf("x s'évalue à vrai.\n");

} else if (y == 8) { // si y vaut 8

    printf("y vaut 8.\n");

} else {

    printf("Ni l'un ni l'autre.\n");

}

```

# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)

## Pièges

```C

int x, y;

x = y = 3;

if (x = 2)

    printf("x = 2 est vrai.\n");

else if (y < 8)

    printf("y < 8.\n");

else if (y == 3)

    printf("y vaut 3 mais cela ne sera jamais affiché.\n");

else

    printf("Ni l'un ni l'autre.\n");

    x = -1; // toujours évalué

```

# Quiz: `if ... else`{.C}

## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)

# Structures de contrôle: `while`{.C}

## La boucle `while`{.C}

```C

while (condition) {

    instructions;

}

do {

    instructions;

} while (condition);

```

## La boucle `while`{.C}, un exemple

```C

int sum = 0; // syntaxe C99

while (sum < 10) {

    sum += 1;

}

do {

    sum += 10;

} while (sum < 100)

```

# Structures de contrôle: `for`{.C}

## La boucle `for`{.C}

```C

for (expression1; expression2; expression3) {

    instructions;

}

```

## La boucle `for`{.C}

```C

int sum = 0; // syntaxe C99

for (int i = 0; i < 10; i++) {

    sum += i;

}

for (int i = 0; i != 1; i = rand() % 4) { // ésotérique

    printf("C'est plus ésotérique.\n");

}

```

slides_2022/cours_10.md0 → 100644

+402
−0

Original line number
Diff line number
Diff line

---

title: "Piles"

date: "2022-12-14"

patat:

  eval:

    tai:

      command: fish

      fragment: false

      replace: true

    ccc:

      command: fish

      fragment: false

      replace: true

  images:

    backend: auto

---

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

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

}

```

# La liste chaînée et pile (1/6)

## Structure de données

* Chaque élément de la liste contient:

    1. une valeur,

    2. un pointeur vers le prochain élément.

* La pile est un pointeur vers le premier élément.

![Un exemple de liste chaînée.](figs/Singly-linked-list.svg){width=80%}

# La liste chaînée et pile (2/6)

## Une pile-liste-chaînée

```C

typedef struct _element {

    int data;

    struct _element *next;

} element;

typedef element* stack;

```

## Fonctionnalités?

. . .

```C

void stack_create(stack *s); // *s = NULL;

void stack_destroy(stack *s);

void stack_push(stack *s, int val);

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

void stack_peek(stack s, int *val);

bool stack_is_empty(stack s); // reutrn NULL == stack;

```

# La liste chaînée et pile (3/6)

## Empiler? (faire un dessin)

. . .

```C

```

## Empiler? (le code ensemble)

. . .

```C

void stack_push(stack *s, int val) {

    element *elem = malloc(sizeof(*elem));

    elem->data = val;

    elem->next = *s;

    s = elem;

}

```

# La liste chaînée et pile (4/6)

## Jeter un oeil? (faire un dessin)

. . .

```C

```

## Jeter un oeil? (le code ensemble)

. . .

```C

void stack_peek(stack s, int *val) {

    *val = s->data;

}

```

# La liste chaînée et pile (5/6)

## Dépiler? (faire un dessin)

. . .

```C

```

## Dépiler? (le code ensemble)

. . .

```C

void stack_pop(stack *s, int *val) {

    stack_peek(*s, val);

    element *tmp = *s;

    *s = (*s)->next;

    free(tmp);

    return val;

}

```

# La liste chaînée et pile (6/6)

## Détruire? (faire un dessin)

. . .

```C

```

## Détruire? (le code ensemble)

. . .

```C

void stack_destroy(stack *s) {

    while (!stack_is_empty(*s)) {

        int val = stack_pop(s);

    }

}

```

slides_2022/cours_11.md0 → 100644

+514
−0

Original line number
Diff line number
Diff line

---

title: "Files d'attente et listes triées"

date: "2022-12-21"

---

# La file d'attente (1/N)

* Structure de données abstraite permettant le stockage d'éléments.

* *FIFO*: First In First Out, ou première entrée première sortie.

* Analogue de la vie "réelle"":

    * File à un guichet,

    * Serveur d'impressions,

    * Mémoire tampon, ...

## Fonctionnalités

 . . .

* Enfiler: ajouter un élément à la fin de la file.

* Défiler: extraire un élément au devant de la file.

* Tester si la file est vide.

. . .

* Lire l'élément de la fin de la file.

* Lire l'élément du devant de la file.

* Créer une liste vide.

* Détruire une liste vide.

# La file d'attente (2/N)

\footnotesize

## Implémentation possible

* La structure file, contient un pointeur vers la tête et un vers le début de la file.

* Entre les deux, les éléments sont stockés dans une liste chaînée.

![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}

## Structure de données en C?

. . .

```C

typedef struct _element {  // Elément de liste

   int data;

   struct _element* next;

} element;

typedef struct _queue {    // File d'attente:

   element* head;  //    tête de file d'attente

   element* tail;  //    queue de file d'attente

} queue;

```

# Fonctionnalités d'une file d'attente

## Creation et consultations

. . .

```C

void queue_init(queue *fa); // head = tail = NULL

bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL

int queue_tail(queue fa); // return fa.head->data

int queue_head(queue fa); // return fa.tail->data

```

## Manipulations et destruction

. . .

```C

void queue_enqueue(queue *fa, int val);

// adds an element before the tail

int queue_dequeue(queue *fa);

// removes the head and returns stored value

void queue_destroy(queue *fa);

// dequeues everything into oblivion

```

# Enfilage

## Deux cas différents:

1. La file est vide (faire un dessin):

. . .

![Insertion dans une file d'attente vide.](./figs/fig_empty_queue_insert.png){width=40%}

2. La file n'est pas vide (faire un dessin):

. . .

![Insertion dans une file d'attente non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}

# Enfilage

## Live (implémentation)

. . .

```C

void queue_enqueue(queue *fa, int val) {

    element* elmt = malloc(sizeof(*elmt));

    elmt->data = val;

    elmt->next = NULL;

    if (queue_is_empty(*fa)) {

        fa->head = elmt;

        fa->tail = elmt;

    } else {

        fa->tail->next = elmt;

        fa->tail = elmt;

    }

}

```

# Défilage

## Trois cas différents

1. La file a plus d'un élément (faire un dessin):

. . .

![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}

2. La file un seul élément (faire un dessin):

. . .

![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}

3. La file est vide (problème)

# Défilage

## Live (implémentation)

. . .

```C

int queue_dequeue(queue *fa) {

    element* elmt = fa->head;

    int val = elmt->data;

    fa->head = fa->head->next;

    free(elmt);

    if (NULL == fa->head) {

        fa->tail = NULL;

    }

    return val;

}

```

. . .

## Problème avec cette implémentation?

# Destruction

## Comment on faire la désallocation?

. . .

On défile jusqu'à ce que la file soit vide!

# Complexité

## Quelle sont les complexité de:

* Enfiler?

. . .

* Défiler?

. . .

* Détruire?

. . .

* Est vide?

# Implémentation alternative

## Comment implémenter la file autrement?

. . .

* Données stockées dans un tableau;

* Tableau de taille connue à la compilation ou pas (réallouable);

* `tail` seraient les indices du tableau;

* `capacity` seraient la capacité maximale;

* On *enfile* "au bout" du tableau, au défile au début (indice `0`).

. . .

## Structure de données

```C

typedef struct _queue {

    int *data;

    int tail, capacity;

} queue;

```

# File basée sur un tableau

* Initialisation?

. . .

```C

```

* Est vide?

. . .

```C

```

* Enfiler?

. . .

```C

```

* Défiler?

. . .

```C

```

# Complexité

## Quelle sont les complexités de:

* Initialisation?

. . .

```C

```

* Est vide?

. . .

```C

```

* Enfiler?

. . .

```C

```

* Défiler?

. . .

```C

```

# Une file plus efficace

## Comment faire une file plus efficace?

* Où est-ce que ça coince?

. . .

* Défiler est particulièrement lent $\mathcal{O}(N)$.

## Solution?

. . .

* Utiliser un indice séparé pour `head`.

```C

typedef struct _queue {

    int *data;

    int head, tail, capacity;

} queue;

```

# Une file plus efficace (implémentation)

## Enfilage

\footnotesize

```C

void queue_enqueue(queue *fa, int val) {

    if ((fa->head == 0 && fa->tail == fa->capacity-1) ||

            (fa->tail == (fa->head-1) % (fa->capacity-1))) {

        return; // queue is full

    }

    if (fa->head == -1) { // queue was empty

        fa->head = fa->tail = 0;

        fa->data[fa->tail] = val;

    } else if (fa->tail == fa->capacity-1 && fa->head != 0) {

        // the tail reached the end of the array

        fa->tail = 0;

        fa->data[fa->tail] = val;

    } else {

        // nothing particular

        fa->tail += 1;

        fa->data[fa->tail] = val;

    }

}

```

# Une file plus efficace (implémentation)

## Défilage

```C

void queue_dequeue(queue *fa, int *val) {

    if (queue_is_empty(*fa)) {

        return; // queue is empty

    }

    *val = fa->data[fa->head];

    if (fa->head == fa->tail) { // that was the last element

        fa->head = fa->tail = -1;

    } else if (fa->head == fa->capacity-1) {

        fa->head = 0;

    } else {

        fa->head += 1;

    }

}

```

# Les listes triées

Une liste chaînée triée est:

* une liste chaînée

* dont les éléments sont insérés dans l'ordre.

![Exemple de liste triée.](./figs/sorted_list_example.svg)

. . .

* L'insertion est faite telle que l'ordre est maintenu.

## Quelle structure de données?

```C

```

# Les listes triées

## Quel but?

* Permet de retrouver rapidement un élément.

* Utile pour la recherche de plus court chemin dans des graphes.

* Ordonnancement de processus par degré de priorité.

## Comment?

* Les implémentations les plus efficaces se basent sur les tableaux.

* Possibles aussi avec des listes chaînées.

# Les listes triées

\footnotesize

## Quelle structure de données dans notre cas?

Une liste chaînée bien sûr (oui c'est pour vous entraîner)!

```C

typedef struct _element { // chaque élément

    int data;

    struct _element *next;

} element;

typedef element* sorted_list; // la liste

```

## Fonctionnalités

```C

// insertion de val

sorted_list sorted_list_push(sorted_list list, int val);

// la liste est-elle vide?

bool is_empty(sorted_list list); // list == NULL

// extraction de val (il disparaît)

sorted_list sorted_list_extract(sorted_list list, int val); 

 // rechercher un élément et le retourner

element* sorted_list_search(sorted_list list, int val);

```

# L'insertion

## Trois cas

1. La liste est vide.

. . .

![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}

. . .

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    if (sorted_list_is_empty(list)) {

        list = malloc(sizeof(*list));

        list->data = val;

        list->next = NULL;

        return list;

    }

}

```

# L'insertion

2. L'insertion se fait en première position.

. . .

![Insertion en tête de liste, `list->data >=

val`.](figs/sorted_list_insert_first.svg){width=80%}

. . .

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    if (list->data >= val) {

        element *tmp = malloc(sizeof(*tmp));

        tmp->data = val;

        tmp->next = list;

        list = tmp;

        return list;

    }

}

```

# L'insertion

3. L'insertion se fait sur une autre position que la première.

. . .

![Insertion sur une autre position, list->data <

val.](figs/sorted_list_insert_any.svg){width=70%}

. . .

\footnotesize

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    element *tmp = malloc(sizeof(*tmp));

    tmp->data = val;

    element *crt = list;

    while (NULL != crt->next && val > crt->next->data) {

        crt = crt->next;

    }

    tmp->next = crt->next;

    crt->next = tmp;

    return list;

}

```

slides_2022/cours_12.md0 → 100644

+409
−0

Original line number
Diff line number
Diff line

---

title: "Listes triées et listes doublement chaînées"

date: "2023-01-11"

---

# Les listes triées

Une liste chaînée triée est:

* une liste chaînée

* dont les éléments sont insérés dans l'ordre.

![Exemple de liste triée.](./figs/sorted_list_example.svg)

. . .

* L'insertion est faite telle que l'ordre est maintenu.

## Quelle structure de données?

```C

```

# Les listes triées

## Quel but?

* Permet de retrouver rapidement un élément.

* Utile pour la recherche de plus court chemin dans des graphes.

* Ordonnancement de processus par degré de priorité.

## Comment?

* Les implémentations les plus efficaces se basent sur les tableaux.

* Possibles aussi avec des listes chaînées.

# Les listes triées

## Quelle structure de données dans notre cas?

Une liste chaînée bien sûr (oui c'est pour vous entraîner)!

```C

typedef struct _element { // chaque élément

    int data;

    struct _element *next;

} element;

typedef element* sorted_list; // la liste

```

## Fonctionnalités

```C

// insertion de val

sorted_list sorted_list_push(sorted_list list, int val);

// la liste est-elle vide?

bool is_empty(sorted_list list); // list == NULL

// extraction de val (il disparaît)

sorted_list sorted_list_extract(sorted_list list, int val); 

 // rechercher un élément et le retourner

element* sorted_list_search(sorted_list list, int val);

```

# L'insertion

## Trois cas

1. La liste est vide.

. . .

![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}

. . .

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    if (sorted_list_is_empty(list)) {

        list = malloc(sizeof(*list));

        list->data = val;

        list->next = NULL;

        return list;

    }

}

```

# L'insertion

2. L'insertion se fait en première position.

. . .

![Insertion en tête de liste, `list->data >=

val`.](figs/sorted_list_insert_first.svg){width=80%}

. . .

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    if (list->data >= val) {

        element *tmp = malloc(sizeof(*tmp));

        tmp->data = val;

        tmp->next = list;

        list = tmp;

        return list;

    }

}

```

# L'insertion

3. L'insertion se fait sur une autre position que la première.

. . .

![Insertion sur une autre position, list->data <

val.](figs/sorted_list_insert_any.svg){width=70%}

. . .

\footnotesize

```C

sorted_list sorted_list_push(sorted_list list, int val) {

    element *tmp = malloc(sizeof(*tmp));

    tmp->data = val;

    element *crt = list;

    while (NULL != crt->next && val > crt->next->data) {

        crt = crt->next;

    }

    tmp->next = crt->next;

    crt->next = tmp;

    return list;

}

```

# L'extraction

## Trois cas

1. L'élément à extraire n'est **pas** le premier élément de la liste

. . .

![Extraction d'un élément qui n'est pas le premier.](figs/sorted_list_extract_any.svg){width=70%}

. . .

\scriptsize

```C

sorted_list sorted_list_extract(sorted_list list, int val) {

    element *prec = *crt = list; // needed to glue elements together

    while (NULL != crt && val > crt->data) {

	   prec = crt;

	   crt = crt->next;

	}

    if (NULL != crt && prec != crt && crt->data == val) { // glue things together

        prec->next = crt->next;

        free(crt);

    }

    return list;

}

```

# L'extraction

2. L'élément à extraire est le premier élément de la liste

. . .

![Extraction d'un élément qui est le premier.](figs/sorted_list_extract_first.svg){width=70%}

. . .

\footnotesize

```C

sorted_list sorted_list_extract(sorted_list list, int val) {

    element *prec = *crt = list; // needed to glue elements together

    while (NULL != crt && val > crt->data) {

	   prec = crt;

	   crt = crt->next;

	}

    if (NULL != crt && crt->data == val && prec == crt) { // glue things together

        list = list->next;

        free(crt);

    }

    return list;

}

```

# L'extraction

3. L'élément à extraire n'est **pas** dans la liste.

    * La liste est vide.

    * La valeur est plus grande que le dernier élément de la liste.

    * La valeur est plus petite que la valeur de `crt`.

. . .

On retourne la liste inchangée.

. . .

\footnotesize

```C

sorted_list sorted_list_extract(sorted_list list, int val) {

    element *prec = *crt = list; // needed to glue elements together

    while (NULL != crt && val > crt->data) {

	   prec = crt;

	   crt = crt->next;

	}

    if (NULL == crt || crt->data != val) { // val not present

        return list;

    }

}

```

# La recherche

```C

element* sorted_list_search(sorted_list list, int val);

```

* Retourne `NULL` si la valeur n'est pas présente (ou la liste vide).

* Retourne un pointeur vers l'élément si la valeur est présente.

. . .

```C

element* sorted_list_search(sorted_list list, int val) {

    // search for element smaller than val

    element* pos = sorted_list_position(list, val); 

    if (NULL == pos && val == list->data) {

        return list; // first element contains val

    } else if (NULL != pos && NULL != pos->next && val == pos->next->data) {

        return pos->next; // non-first element contains val

    } else {

        return NULL; // well... val's not here

    }

}

```

# La recherche

## La fonction `sorted_list_position`

```C

element* sorted_list_position(sorted_list list, int val);

```

![Trois exemples de retour de la fonction `sorted_list_position()`.](figs/sorted_list_position.svg)

# La recherche

## Exercice: implémenter

```C

element* sorted_list_position(sorted_list list, int val);

```

. . .

```C

element* sorted_list_position(sorted_list list, int val) {

    element* pos = list;

    if (sorted_list_is_empty(list) || val <= list->data) {

        pos = NULL;

    } else {

        while (NULL != pos->next && val > pos->next->data) {

            pos = pos->next;

        }

    }

    return pos;

}

```

# Complexité de la liste chaînée triée

## L'insertion?

. . .

$$

\mathcal{O}(N).

$$

## L'extraction?

. . .

$$

\mathcal{O}(N).

$$

## La recherche?

. . .

$$

\mathcal{O}(N).

$$

# Liste doublement chaînée

## Application: navigateur ou éditeur de texte

* Avec une liste chaînée:

    * Comment implémenter les fonctions `back` et `forward` d'un navigateur?

    * Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?

. . .

Pas possible.

## Solution?

. . .

* Garder un pointeur supplémentaire sur l'élément précédent et pas seulement le

  suivant.

. . .

* Cette structure de donnée est la **liste doublement chaînée** ou **doubly

  linked list**.

# Liste doublement chaînée

## Exercices

* Partir du dessin suivant et par **groupe de 5**

![Un schéma de liste doublement chaînée d'entiers.](figs/doubly_linked_list.svg)

1. Écrire les structures de données pour représenter la liste doublement

   chaînée dont le type sera `dll` (pour

   `doubly_linked_list`)

# Liste doublement chaînée

2. Écrire les fonctionnalités de création et consultation

```C 

// crée la liste doublement chaînée

dll dll_create();

// retourne la valeur à la position actuelle dans la liste

int dll_value(dll list);

// la liste est-elle vide?

bool dll_is_empty(dll list);

// Est-ce que pos est le 1er élément?

bool dll_is_head(dll list);

// Est-ce que pos est le dernier élément?

bool dll_is_tail(dll list);

// data est-elle dans la liste?

bool dll_is_present(dll list, int data);

// affiche la liste

void dll_print(dll list);

```

# Liste doublement chaînée

3. Écrire les fonctionnalités de manipulation 

```C 

// déplace pos au début de la liste

dll dll_move_to_head(dll list);

// déplace pos à la position suivante dans la liste

dll dll_next(dll list);

// déplace pos à la position précédente dans la liste

dll dll_prev(dll list);

```

# Liste doublement chaînée

4. Écrire les fonctionnalités d'insertion

```C

// insertion de data dans l'élément après pos

dll dll_insert_after(dll list, int data);

// insertion de data en tête de liste

dll dll_push(dll list, int data);

```

5. Écrire les fonctionnalités d'extraction

```C

// extraction de la valeur se trouvant dans l'élément pos

// l'élément pos est libéré

int dll_extract(dll *list);

// extrait la donnée en tête de liste

int dll_pop(dll *list);

// vide la liste

void dll_destroy(dll *list)

```

slides_2022/cours_13.md0 → 100644

+605
−0

Original line number
Diff line number
Diff line

---

title: "Tables de hachage"

date: "2023-01-18"

---

# Tableau vs Table

## Tableau

* Chaque élément (ou valeur) est lié à un indice (la case du tableau).

```C 

annuaire tab[2] = {

    "+41 22 123 45 67", "+41 22 234 56 78", ...

};

tab[1] == "+41 22 123 45 67";

```

## Table

* Chaque élément (ou valeur) est lié à une clé.

```C 

annuaire tab = {

//  Clé   ,    Valeur

    "Paul",    "+41 22 123 45 67",

    "Orestis", "+41 22 234 56 78",

};

tab["Paul"]    == "+41 22 123 45 67";

tab["Orestis"] == "+41 22 234 56 78";

```

# Table

## Définition

Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou

argument).

On parle de paires *clé-valeur* (*key-value pairs*).

## Donnez des exemples de telles paires

. . .

* Annuaire (nom-téléphone),

* Catalogue (objet-prix),

* Table de valeur fonctions (nombre-nombre),

* Index (nombre-page)

* ...

# Table

## Opérations principales sur les tables

* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`

* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`

* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`

## Structure de données / implémentation

Efficacité dépend de différents paramètres:

* taille (nombre de clé-valeurs maximal),

* fréquence d'utilisation (insertion, consultation, suppression),

* données triées/non-triées,

* ...

# Consultation séquentielle (`sequential_get`)

## Séquentielle

* table représentée par un (petit) tableau ou liste chaînée,

* types: `key_t` et `value_t` quelconques, et `key_value_t`

    ```C

    typedef struct {

        key_t key;

        value_t value;

    } key_value_t;

    ```

* on recherche l'existence de la clé séquentiellement dans le tableau, on

  retourne la valeur.

# Consultation séquentielle (`sequential_get`)

## Implémentation? Une idée?

. . .

```C

bool sequential_get(int n, key_value_t table[n], key_t key, 

    value_t *value) 

{

    int pos = n - 1;

    while (pos >= 0) {

        if (key ==  table[pos].key) {

            *value = table[pos].value;

            return true;

        }

        pos--;

    }

    return false;

}

```

. . .

## Inconvénient?

# Consultation séquentielle (`sequential_get`)

## Exercice: implémenter la même fonction avec une liste chaînée

Poster le résultat sur matrix.

# Consultation dichotomique (`binary_get`)

## Dichotomique

* table représentée par un (petit) tableau trié par les clés,

* types: `key_t` et `value_t` quelconques, et `key_value_t`

* on recherche l'existence de la clé par dichotomie dans le tableau, on

  retourne la valeur,

* les clés possèdent la notion d'ordre (`<, >, =` sont définis).

# Consultation dichotomique (`binary_get`)

\footnotesize

## Implémentation? Une idée?

. . .

```C

bool binary_get1(int n, value_key_t table[n], key_t key, value_t *value) {

    int top = n - 1, bottom = 0;

    while (top > bottom) { 

        int middle = (top + bottom) / 2;

        if (key > table[middle].key) {

            bottom  = middle+1;

        } else {

            top = middle;

        }

    }

    if (key == table[top].key) {

        *value = table[top].value;

        return true;

    } else {

        return false;

    }

} 

```

# Consultation dichotomique (`binary_get`)

\footnotesize

## Autre implémentation

```C

bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {

    int top = n - 1, bottom = 0;

    while (true) { 

        int middle = (top + bottom) / 2;

        if (key > table[middle].key) {

            bottom  = middle + 1;

        } else if (key < table[middle].key) {

            top = middle;

        } else {

            *value = table[middle].value;

            return true;

        }

        if (top < bottom) {

             break;

        }

    }

    return false;

}

```

## Quelle est la différence avec le code précédent?

# Transformation de clé (hashing)

## Problématique: Numéro AVS (13 chiffres)

* Format: 106.3123.8492.13

    ```

    Numéro AVS    | Nom

    0000000000000 | -------

    ...           | ...

    1063123849213 | Paul

    ...           | ...

    3066713878328 | Orestis

    ...           | ...

    9999999999999 | -------

    ```

## Quelle est la clé? Quelle est la valeur?

. . .

* Clé: Numéro AVS, Valeur: Nom.

## Nombre de clés? Nombre de citoyens? Rapport?

. . .

* $10^{13}$ clés, $10^7$ citoyens, $10^{-5}$ ($10^{-3}\%$ de la table est

  occupée) $\Rightarrow$ *inefficace*.

* Pire: $10^{13}$ entrées ne rentre pas dans la mémoire d'un

  ordinateur.

# Transformation de clé (hashing)

## Problématique 2: Identificateurs d'un programme

* Format: 8 caractères (simplification)

    ```

    Identificateur | Adresse

    aaaaaaaa       | -------

    ...            | ...

    resultat       | 3aeff

    compteur       | 4fedc

    ...            | ...

    zzzzzzzz       | -------

    ```

## Quelle est la clé? Quelle est la valeur?

. . .

* Clé: Identificateur, Valeur: Adresse.

## Nombre de clés? Nombre d'identificateur d'un programme? Rapport?

. . .

* $26^{8}\sim 2\cdot 10^{11}$ clés, $2000$ identificateurs, $10^{-8}$ ($10^{-6}\%$ de la table est

  occupée) $\Rightarrow$ *un peu inefficace*.

# Fonctions de transformation de clé (hash functions)

* La table est représentée avec un tableau.

* La taille du tableau est beaucoup plus petit que le nombre de clés.

* On produit un indice du tableau à partir d'une clé:

$$

h(key) = n,\quad n\in\mathbb{N}.

$$

En français: on transforme `key` en nombre entier qui sera l'indice dans le

tableau correspondant à `key`.

## La fonction de hash

* La taille du domaine des clés est beaucoup plus grand que le domaine des

  indices.

* Plusieurs indices peuvent correspondre à la **même clé**:

    * Il faut traiter les **collisions**.

* L'ensemble des indices doit être plus petit ou égal à la taille de la table.

## Une bonne fonction de hash

* Distribue uniformément les clés sur l'ensemble des indices.

# Fonctions de transformation de clés: exemples

## Méthode par troncature

\begin{align*}

&h: [0,9999]\rightarrow [0,9]\\

&h(key)=\mbox{troisième chiffre du nombre.}

\end{align*}

```

Key  | Index

0003 | 0

1123 | 2 \

1234 | 3  |-> collision.

1224 | 2 / 

1264 | 6 

```

## Quelle est la taille de la table?

. . .

C'est bien dix oui.

# Fonctions de transformation de clés: exemples

## Méthode par découpage

Taille de l'index: 3 chiffres.

```

key = 321 991 24 ->  321

                     991

                    + 24

                    ----

                    1336 -> index = 336

```

## Devinez l'algorithme?

. . .

On part de la gauche:

1. On découpe la clé en tranche de longueur égale à celle de l'index.

2. On somme les nombres obtenus.

3. On tronque à la longueur de l'index.

# Fonctions de transformation de clés: exemples

## Méthode multiplicative

Taille de l'index: 2 chiffres.

```

key = 5486 -> key^2 = 30096196 -> index = 96

```

On prend le carré de la clé et on garde les chiffres du milieu du résultat.

# Fonctions de transformation de clés: exemples

## Méthode par division modulo

Taille de l'index: `N` chiffres.

```

h(key) = key % N.

```

## Quelle doit être la taille de la table?

. . .

Oui comme vous le pensiez au moins `N`.

# Traitement des collisions

## La collision

```

key1 != key2, h(key1) == h(key2)

```

## Traitement (une idée?)

. . .

* La première clé occupe la place prévue dans le tableau.

* La deuxième (troisième, etc.) est placée ailleurs de façon **déterministe**.

Dans ce qui suit la taille de la table est `table_size`.

# La méthode séquentielle

\footnotesize

## Comment ça marche?

* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en

  trouver une libre.

```C

index = h(key);

while (table[index].state == OCCUPIED && table[index].key != key) {

   index = (index + 1) % table_size; // attention à pas dépasser

}

table[index].key = key;

table[index].state = OCCUPIED;

```

## Problème?

. . .

* Regroupement d'éléments (clustering).

# Méthode linéaire

\footnotesize

## Comment ça marche?

* Comme la méthode séquentielle mais on "saute" de `k`.

```C

index = h(key);

while (table[index].state == OCCUPIED && table[index].key != key) {

   index = (index + k) % table_size; // attention à pas dépasser

}

table[index].key = key;

table[index].state = OCCUPIED;

```

## Quelle valeur de `k` éviter?

. . .

* Une valeur où  `table_size` est multiple de `k`.

Cette méthode répartit mieux les regroupements au travers de la table.

# Méthode du double hashing

\footnotesize

## Comment ça marche?

* Comme la méthode linéaire, mais `k = h2(key)` (variable).

```C

index = h(key);

while (table[index].state == OCCUPIED && table[index].key != key) {

   index = (index + h2(k)) % table_size; // attention à pas dépasser

}

table[index].key = key;

table[index].state = OCCUPIED;

```

## Quelle propriété doit avoir `h2`?

## Exemple

```C

h2(key) = (table_size - 2) - key % (table_size -2)

```

# Méthode pseudo-aléatoire

\footnotesize

## Comment ça marche?

* Comme la méthode linéaire mais on génère `k` pseudo-aléatoirement.

    ```C

    index = h(key);

    while (table[index].state == OCCUPIED && table[index].key != key) {

        index = (index + random_number) % table_size;

    }

    table[index].key = key;

    table[index].state = OCCUPIED;

    ```

## Comment s'assurer qu'on va bien retrouver la bonne clé?

. . .

* Le germe (seed) de la séquence pseudo-aléatoire doit être le même.

* Le germe à choisir est l'index retourné par `h(key)`.

    ```C

    srand(h(key));

    while {

        random_number = rand();

    }

    ```

# Méthode quadratique

* La fonction des indices de collision est de degré 2.

* Soit $J_0=h(key)$, les indices de collision se construisent comme:

    ```C 

    J_i = J_0 + i^2 % table_size, i > 0,

    J_0 = 100, J_1 = 101, J_2 = 104, J_3 = 109, ...

    ```

## Problème possible?

. . .

* Calculer le carré peut-être "lent".

* En fait on peut ruser un peu.

# Méthode quadratique

\footnotesize

```C 

J_i = J_0 + i^2 % table_size, i > 0,

J_0 = 100

          \

           d_0 = 1 

          /        \

J_1 = 101           Delta = 2

          \        /

           d_1 = 3

          /        \

J_2 = 104           Delta = 2

          \        /

           d_2 = 5

          /        \

J_3 = 109           Delta = 2

          \        /

           d_3 = 7

          /        

J_4 = 116

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

J_{i+1} = J_i + d_i,

d_{i+1} = d_i + Delta, d_0 = 1, i > 0.

```

# Méthode de chaînage

## Comment ça marche?

* Chaque index de la table contient un pointeur vers une liste chaînée

  contenant les paires clés-valeurs.

## Un petit dessin

```

```

# Méthode de chaînage

## Exemple

On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre

de l'alphabet)

```

 U  | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E

 10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5

```

## Comment on représente ça? (à vous)

. . .

![La méthode de chaînage](figs/fig_hash.png){width=80%}

# Méthode de chaînage

Avantages:

* Si les clés sont grandes l'économie de place est importante (les places vides

  sont `NULL`).

* La gestion des collisions est conceptuellement simple.

* Pas de problème de regroupement (clustering).

# Exercice 1

* Construire une table à partir de la liste de clés suivante:

    ```

    R, E, C, O, U, P, A, N, T

    ```

* On suppose que la table est initialement vide, de taille $n = 13$.

* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.

# Exercice 2

* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter

  les collisions avec

\begin{align*}

h_1(k)&=k\mod 13,\\

h_2(k)&=1+(k\mod 11).

\end{align*}

* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de

  collision.

# Exercice 3

* Stocker les numéros de téléphones internes d'une entreprise suivants dans un

tableau de 10 positions.

* Les numéros sont compris entre 100 et 299.

* Soit $N$ le numéro de téléphone, la fonction de hachage est

$$

h(N)=N\mod 10.

$$

* La fonction de gestion des collisions est

$$

C_1(N,i)=(h(N)+3\cdot i)\mod 10.

$$

* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).

* Supprimer 175 (rechercher 175, et mettre son état à supprimé).

* Rechercher 35.

* Les cases ni supprimées, ni occupées sont vides.

* Expliquer se qui se passe si on utilise?

$$

C_1(N,i)=(h(N)+5\cdot i)\mod 10.

$$

slides_2022/cours_14.md0 → 100644

+367
−0

Original line number
Diff line number
Diff line

---

title: "Tables de hachage"

date: "2023-02-24"

patat:

  eval:

    tai:

      command: fish

      fragment: false

      replace: true

    ccc:

      command: fish

      fragment: false

      replace: true

  images:

    backend: auto

---

# Rappel sur les tables de hachage (1/N)

## Définition? Qui se souvient?

. . .

Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou

argument).

On parle de paires *clé-valeur* (*key-value pairs*).

## Donnez des exemples de telles paires

. . .

* Annuaire (nom-téléphone),

* Catalogue (objet-prix),

* Table de valeur fonctions (nombre-nombre),

* Index (nombre-page)

* ...

# Rappel sur les tables de hachage (1/N)

## Opérations principales sur les tables

* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`

* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`

* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`

## Transformation de clé (hashing)

* Format: 106.3123.8492.13

    ```

    Numéro AVS    | Nom

    0000000000000 | -------

    ...           | ...

    1063123849213 | Paul

    ...           | ...

    3066713878328 | Orestis

    ...           | ...

    9999999999999 | -------

    ```

* Nombre de numéros >> nombre d'entrées.

# Fonctions de transformation de clé (hash functions)

* La table est représentée avec un tableau.

* La taille du tableau est beaucoup plus petit que le nombre de clés.

* On produit un indice du tableau à partir d'une clé:

$$

h(key) = n,\quad n\in\mathbb{N}.

$$

En français: on transforme `key` en nombre entier qui sera l'indice dans le

tableau correspondant à `key`.

## La fonction de hash

* La taille du domaine des clés est beaucoup plus grand que le domaine des

  indices.

* Plusieurs indices peuvent correspondre à la **même clé**:

    * Il faut traiter les **collisions**.

* L'ensemble des indices doit être plus petit ou égal à la taille de la table.

## Une bonne fonction de hash

* Distribue uniformément les clés sur l'ensemble des indices.

# Fonctions de transformation de clés: exemple

## Méthode par division modulo

Taille de l'index: `N` chiffres.

```

h(key) = key % N.

```

## Quelle doit être la taille de la table?

. . .

Oui comme vous le pensiez au moins `N`.

# Traitement des collisions

## La collision

```

key1 != key2, h(key1) == h(key2)

```

## Traitement (une idée?)

. . .

* La première clé occupe la place prévue dans le tableau.

* La deuxième (troisième, etc.) est placée ailleurs de façon **déterministe**.

Dans ce qui suit la taille de la table est `table_size`.

# La méthode séquentielle

\footnotesize

* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en

  trouver une libre.

```C

index = h(key);

while (table[index].state == OCCUPIED && table[index].key != key) {

   index = (index + 1) % table_size; // attention à pas dépasser

}

table[index].key = key;

table[index].state = OCCUPIED;

```

# Méthode de chaînage

## Comment ça marche?

* Chaque index de la table contient un pointeur vers une liste chaînée

  contenant les paires clés-valeurs.

## Un petit dessin

```

```

# Méthode de chaînage

## Exemple

On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre

de l'alphabet)

```

 U  | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E

 10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5

```

## Comment on représente ça? (à vous)

. . .

![La méthode de chaînage](figs/fig_hash.png){width=80%}

# Exercice 1

* Construire une table à partir de la liste de clés suivante:

    ```

    R, E, C, O, U, P, A, N, T

    ```

* On suppose que la table est initialement vide, de taille $n = 13$.

* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.

# Exercice 2

* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter

  les collisions avec

\begin{align*}

h_1(k)&=k\mod 13,\\

h_2(k)&=1+(k\mod 11).

\end{align*}

* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de

  collision.

# Exercice 3

* Stocker les numéros de téléphones internes d'une entreprise suivants dans un

tableau de 10 positions.

* Les numéros sont compris entre 100 et 299.

* Soit $N$ le numéro de téléphone, la fonction de hachage est

$$

h(N)=N\mod 10.

$$

* La fonction de gestion des collisions est

$$

C_1(N,i)=(h(N)+3\cdot i)\mod 10.

$$

* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).

* Supprimer 175 (rechercher 175, et mettre son état à supprimé).

* Rechercher 35.

* Les cases ni supprimées, ni occupées sont vides.

* Expliquer se qui se passe si on utilise?

$$

C_1(N,i)=(h(N)+5\cdot i)\mod 10.

$$

# Préambule

\small

* On considère pas le cas du chaînage en cas de collisions.

* L'insertion est construite avec une forme du type

    ```C

    index = h(key);

    while (table[index].state == OCCUPIED 

           && table[index].key != key) {

       index = (index + k) % table_size; // attention à pas dépasser

    }

    table[index].key = key;

    table[index].state = OCCUPIED;

    ```

\normalsize

* Gestion de l'état d'une case *explicite*

    ```C

    typedef enum {EMPTY, OCCUPIED, DELETED} state;

    ```

# L'insertion

## Pseudocode?

. . .

```C

insert(table, key, value) {

    index = hash de la clé;

    index = 

        si "index" est déjà "occupé"

        et la clé correspondante n'est pas "key"

        alors gérer la collision;

    changer l'état de la case "index" à "occupé";

    changer la valeur de la case "index" à "value";

}

```

# La suppression

## Pseudocode?

. . .

```C

value_t remove(table, key) {

    index = hash de la clé;

    tant que l'état de la case n'est pas "vide"

        si "index" est "occupé" et la clé est "key" 

            changer l'état de la case à "supprimé"

        sinon

            index = rehash

}

```

# La recherche

## Pseudocode?

. . .

```C

bool search(table, key, value) {

    index = hash de la clé;

    tant que l'état de la case n'est pas "vide"

        si "index" est "occupé" et la clé est "key" 

            retourner vrai

        sinon

            index = rehash

}

```

# Écrivons le code!

* Mais avant:

    * Quelles sont les structures de données dont nous avons besoin?

    * Y a-t-il des fonctions auxiliaires à écrire?

    * Écrire les signatures des fonctions.

. . .

## Structures de données

\footnotesize

. . .

```C

typedef enum {empty, deleted, occupied};

typedef ... key_t;

typedef ... value_t;

typedef struct _cell_t {

    key_t key; 

    value_t value;

    state_t state;

} cell_t;

typedef struct _hm {

    cell_t *table;

    int capacity;

    int size;

} hm;

```

# Écrivons le code!

## Fonctions auxiliaires

. . .

```C

static int hash(key_t key);

static int rehash(int index, key_t key);

static int find_index(hm h, key_t key);

```

##  Signature de l'API 

. . .

```C

void hm_init(hm *h, int capacity);

void hm_destroy(hm *h);

bool hm_set(hm *h, key_t key, value_t *value);

bool hm_get(hm h, key_t key, value_t *value);

bool hm_remove(hm *h, key_t key, value_t *value);

bool hm_search(hm h, key_t key);

void hm_print(hm h);

Compare revisions

Source

Target

Files

Some changes are not shown.

README.md

slides/.gitignore

slides/Makefile

slides/cours_1.md

slides/docker-compose.yml

slides/intro.md

slides/metadata.yaml

slides_2022/Makefile

slides_2022/cours_1.md

slides_2022/cours_10.md

slides_2022/cours_11.md

slides_2022/cours_12.md

slides_2022/cours_13.md

slides_2022/cours_14.md