Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • main
1 result

Target

Select target project
No results found
Select Git revision
  • master
1 result
Show changes
688 files
+ 142314
− 285
Compare changes
  • Side-by-side
  • Inline

Files

README.md

0 → 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.yml

0 → 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/Makefile

0 → 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.md

0 → 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/cours_11.md→slides_2022/cours_11.md

+1 −1
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ void queue_destroy(queue *fa); 


```C

void queue_enqueue(queue *fa, int val) {

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

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

    elmt->data = val;

    elmt->next = NULL;

    if (queue_is_empty(*fa)) {

slides_2022/cours_13.md

0 → 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.md

0 → 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);

```



# Live code session! 



0. Offered to you by ProtonVPN[^1]!



. . .



1. Like the video.

2. Subscribe to the channel.

3. Use our one time voucher for ProtonVPN: `PAULISAWESOME`.

4. Consider donating on our patreon.



[^1]: The fastest way to connect to BBB!

slides_2022/cours_15.md

0 → 100644
+929 −0
Original line number Diff line number Diff line 
---

title: "Arbres"

date: "2023-03-10"

---



# Les arbres: définition



"Un arbre est un graphe acyclique orienté possédant une unique racine, et tel que tous les nœuds sauf la racine ont un unique parent."



. . .



**Santé!**



## Plus sérieusement



* Ensemble de **nœuds** et d'**arêtes** (graphe),

* Les arêtes relient les nœuds entre eux, mais pas n'importe comment: chaque

  nœud a au plus un **parent**,

* Le seul nœud sans parent est la **racine**,

* Chaque nœud a un nombre fini de **fils**,

* La hiérarchie des nœuds rend les arêtes **orientées** (parent -> fils), et empêche les

  **cycles** (acyclique, orienté).

* La **feuille** ou **nœud terminal** est un nœud sans enfants,

* Le **niveau** est 1 à la racine et **niveau+1** pour les fils,

* Le **degré** d'un nœud est le nombre de fils du nœud.



. . .



* Chaque nœud est un arbre en lui même.

* La **récursivité** sera très utile!





# Arbre ou pas arbre?



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    1-->2;

    1-->3;

    3-->2;

    3-->4;

    3-->5;

```

::::



. . .



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    1-->2;

    1-->3;

    3-->4;

    3-->5;

    3-->6;

```

::::



:::



# Arbre ou pas arbre?



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    1-->2;

    1-->3;

    3-->4;

    3-->5;

    3-->6;

    6-->7;

    7-->3;

```

::::



. . .



:::: column

```{.mermaid format=pdf width=300 loc=figs/}

graph TD;

    1;

```

::::



:::



# Arbre ou pas arbre?



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    1---2;

    1---3;

    3---4;

    3---5;

```

::::



. . .



:::: column

```{.mermaid format=pdf width=300 loc=figs/}

graph BT;

    1-->2;

    1-->3;

    3-->4;

    3-->5;

    3-->6;

```

::::



:::



# Degré et niveau



* Illustration du degré (nombre de fils) et du niveau (profondeur)



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    1[degré 2]-->2[degré 0];

    1-->3[degré 3];

    3-->4[degré 0];

    3-->5[degré 0];

    3-->6[degré 0];

```

::::



. . .



:::: column

```{.mermaid format=pdf width=300 loc=figs/}

graph TD;

    1[niveau 1]-->2[niveau 2];

    1-->3[niveau 2];

    3-->4[niveau 3];

    3-->5[niveau 3];

    3-->6[niveau 3];

```

::::



:::



* Les nœuds de degré 0, sont des feuilles.



# Application: recherche rapide



## Pouvez vous construire un arbre pour résoudre le nombre secret?



 . . .



* Le nombre secret ou la recherche dichotomique (nombre entre 0 et 10).



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph LR;

    5-->|<|2;

    5-->|>|7;

    7-->|>|8;

    7-->|<|6;

    8-->|>|9;

    9-->|>|10;

    2-->|<|1;

    2-->|>|3;

    3-->|>|4;

    1-->|<|0;

```

::::



:::: column



**Question:** Quelle est la complexité pour trouver un nombre?



::::



:::



# Autres représentation



* Botanique

* **Exercice:** Ajouter les degrés/niveaux et feuilles



```{.mermaid width=250 format=pdf loc=figs/}

graph TD;

    A-->B;

    A-->C;

    B-->D;

    B-->E;

    B-->F;

    F-->I;

    F-->J;

    C-->G;

    C-->H;

    H-->K;

```



# Autres représentation



* Ensembliste



::: columns



:::: column

```{.mermaid width=300 format=pdf loc=figs/}

graph TD;

    A-->B;

    A-->C;

    B-->D;

    B-->E;

    B-->F;

    F-->I;

    F-->J;

    C-->G;

    C-->H;

    H-->K;

```

::::



. . .



:::: column

![](figs/ensemble.svg)

::::



:::



# Autres représentation



* Liste



::: columns



:::: column

```{.mermaid width=400 format=pdf loc=figs/}

graph TD;

    A-->B;

    A-->C;

    B-->D;

    B-->E;

    B-->F;

    F-->I;

    F-->J;

    C-->G;

    C-->H;

    H-->K;

```

::::



. . .



:::: column

```

(A 

    (B 

        (D) 

        (E) 

        (F 

            (I) 

            (J)

        )

    ) 

    (C

        (G) 

        (H 

            (K)

        )

    )

)

```

::::



:::



# Autres représentation



* Par niveau



::: columns



:::: column

```{.mermaid width=400 format=pdf loc=figs/}

graph TD;

    A-->B;

    A-->C;

    B-->D;

    B-->E;

    B-->F;

    F-->I;

    F-->J;

    C-->G;

    C-->H;

    H-->K;

```

::::



. . .



:::: column

```

1       2       3       4

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

A       

        B       

                D 

                E 

                F           

                        I

                        J

        C       

                G

                H

                        K

```

::::



:::



# L'arbre binaire



* Structure de données abstraite,

* Chaque nœud a au plus deux fils: gauche et droite,

* Chaque fils est un arbre.



## Comment représenteriez vous une telle structure?



. . .



```C

<R, G, D>

    R: racine

    G: sous-arbre gauche

    D: sous-arbre droite

```



## Comment cela s'écrirait en C?



. . .



```C

typedef struct _node {

    contenu info;

    struct _node *left, *right;

} node;

typedef node *tree;

```



# L'arbre binaire



## Que se passerait-il avec 



```C

typedef struct _node {

    int info;

    struct _node left, right;

} node;

```



* On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!



## Interface minimale



* Qu'y mettriez vous?



. . .



```C 

NULL              -> arbre (vide)

<n, arbre, arbre> -> arbre

visiter(arbre)    -> nœud (la racine de l'arbre)

gauche(arbre)     -> arbre (sous-arbre de gauche)

droite(arbre)     -> arbre (sous-arbre de droite)

```



* Les autres opérations (insertion, parcours, etc) dépendent de ce qu'on stocke

  dans l'arbre.



# Exemple d'arbre binaire



* Représentez `(c - a * b) * (d + e / f)` à l'aide d'un arbre binaire (matrix)



. . .



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    A[*]-->B[-];

    B-->C[c];

    B-->D[*];

    D-->E[a];

    D-->F[b];

    A-->G[+];

    G-->H[d];

    G-->I["/"];

    I-->J[e];

    I-->K[f];

```

::::





:::: column



## Remarques



* L'arbre est **hétérogène**: le genre d'info est pas le même sur chaque nœud

  (opérateur, opérande).

    * Les feuilles contiennent les opérandes.

    * Les nœuds internes contiennent les opérateurs.



::::



:::



# Parcours d'arbres binaires



* Appliquer une opération à tous les nœuds de l'arbre,

* Nécessité de **parcourir** l'arbre,

* Utiliser uniquement l'interface: visiter, gauche,

  droite.



## Une idée de comment parcourir cet arbre?



* 3 parcours (R: Racine, G: sous-arbre gauche, D: sous-arbre droit):





::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    A[*]-->B[-];

    B-->C[c];

    B-->D[*];

    D-->E[a];

    D-->F[b];

    A-->G[+];

    G-->H[d];

    G-->I["/"];

    I-->J[e];

    I-->K[f];

```

::::



:::: column



1. Parcours **préfixe** (R, G D),

2. Parcours **infixe** (G, R, D),

3. Parcours **postfixe** (G, D, R).



::::



:::



# Le parcours infixe (G, R, D)



* Gauche, Racine, Droite:

    1. On descend dans l'arbre de gauche tant qu'il est pas vide,

    2. On visite la racine du sous arbre,

    3. On descend dans le sous-arbre de droite (s'il est pas vide),

    4. On recommence.



. . .



## Incompréhensible?



* La récursivité c'est la vie.

    

```

parcours_infixe(arbre a)

    si est_pas_vide(gauche(a))

       parcours_infixe(gauche(a))

    visiter(A)

    si est_pas_vide(droite(A))

       parcours_infixe(droite(A))

```



# Graphiquement (dessinons)



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    A[*]-->B[-];

    B-->C[c];

    B-->D[*];

    D-->E[a];

    D-->F[b];

    A-->G[+];

    G-->H[d];

    G-->I["/"];

    I-->J[e];

    I-->K[f];

```

::::



:::: column



```

parcours_infixe(arbre a)

    si est_pas_vide(gauche(a))

       parcours_infixe(gauche(a))

    visiter(A)

    si est_pas_vide(droite(A))

       parcours_infixe(droite(A))

```



::::



:::





# Graphiquement (`mermaid` c'est super)



::: columns



:::: column

```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    A[*]-->B[-];

    A[*]-.->|1|B[-];

    B-->C[c];

    B-.->|2|C[c];

    C-.->|3|B;

    B-->D[*];

    B-.->|4|D;

    D-->E[a];

    D-.->|5|E;

    E-.->|6|D;

    D-->F[b];

    D-.->|7|F;

    F-.->|8|A;

    A-->G[+];

    A-.->|9|G;

    G-->H[d];

    G-.->|10|H;

    H-.->|11|G;

    G-->I["/"];

    G-.->|12|I;

    I-->J[e];

    I-.->|13|J;

    J-.->|14|I;

    I-->K[f];

    I-.->|15|K;

```

::::



:::: column



```

parcours_infixe(arbre a)

    si est_pas_vide(gauche(a))

       parcours_infixe(gauche(a))

    visiter(A)

    si est_pas_vide(droite(A))

       parcours_infixe(droite(A))

```



## Remarque 



Le nœud est visité à la **remontée**.



## Résultat



```

c - a * b * d + e / f

```



::::



:::



# Et en C?



## Live code



\footnotesize



. . .



```C

typedef int data;

typedef struct _node {

    data info;

    struct _node* left;

    struct _node* right;

} node;

typedef node* tree_t;

void tree_print(tree_t tree, int n) {

    if (NULL != tree) {

        tree_print(tree->left, n+1);

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

            printf(" ");

        }

        printf("%d\n", tree->info);

        tree_print(tree->right, n+1);

    }

}

```



# Question



## Avez-vous compris le fonctionnement?



. . .



## Vous en êtes sûr·e·s?



. . .



## OK, alors deux exercices:



1. Écrire le pseudo-code pour le parcours R, G, D (matrix).

2. Écrire le pseudo-code pour la parcours G, D, R (matrix),



## Rappel



```

parcours_infixe(arbre a)

    si est_pas_vide(gauche(a))

       parcours_infixe(gauche(a))

    visiter(A)

    si est_pas_vide(droite(A))

       parcours_infixe(droite(A))

```



# Correction



\footnotesize



* Les deux parcours sont des modifications **triviales**[^1] de l'algorithme

  infixe.



## Le parcours postfixe



```python

parcours_postfixe(arbre a)

    si est_pas_vide(gauche(a))

       parcours_postfixe(gauche(a))

    si est_pas_vide(droite(a))

       parcours_postfixe(droite(a))

    visiter(a)

```



## Le parcours préfixe



```python

parcours_préfixe(arbre a)

    visiter(a)

    si est_pas_vide(gauche(a))

        parcours_préfixe(gauche(a))

    si est_pas_vide(droite(a))

        parcours_préfixe(droite(a))

```



. . .



**Attention:** L'implémentation de ces fonctions en C sont **à faire** en

exercice (inspirez vous de ce qu'on a fait avant)!



# Exercice: parcours



## Comment imprimer l'arbre ci-dessous?



```

                        f

                /

                        e

        +

                d

*

                c

        -

                        b

                *

                        a

```



. . .



## Bravo vous avez trouvé! 



* Il s'agissait du parcours D, R, G.



# Implémentation



## Vous avez 5 min pour implémenter cette fonction et la poster sur matrix!



. . .



```C 

void pretty_print(tree_t tree, int n) {

    if (NULL != tree) {

        pretty_print(tree->right, n+1);

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

            printf(" ");

        }

        printf("%d\n", tree->info);

        pretty_print(tree->left, n+1);

    }

}

```



# Exercice supplémentaire (sans corrigé)



Écrire le code de la fonction 



```C

int depth(tree_t t);

```



qui retourne la profondeur maximale d'un arbre.



Indice: la profondeur à chaque niveau peut-être calculée à partir du niveau des

sous-arbres de gauche et de droite.



# La recherche dans un arbre binaire



* Les arbres binaires peuvent retrouver une information très rapidement.

* À quelle complexité? À quelle condition?



. . .



## Condition



* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`

  entre les éléments).



## Complexité



* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)



. . .



## Exemple: les arbres lexicographiques



* Chaque nœud contient une information de type ordonné, la **clé**,

* Par construction, pour chaque nœud $N$:

    * Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.

    * Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.



# Algorithme de recherche



* Retourner le nœud si la clé est trouvée dans l'arbre.



```python

arbre recherche(clé, arbre)

    tante_que est_non_vide(arbre)

        si clé < clé(arbre)

            arbre = gauche(arbre)

        sinon si clé > clé(arbre)

            arbre = droite(arbre)

        sinon

            retourne arbre

    retourne NULL

```



# Algorithme de recherche, implémentation (live)



\footnotesize



. . .



```C 

typedef int key_t;

typedef struct _node {

    key_t key;

    struct _node* left;

    struct _node* right;

} node;

typedef node* tree_t;

tree_t search(key_t key, tree_t tree) {

    tree_t current = tree;

    while (NULL != current) {

        if (current->key > X) {

            current = current->gauche;

        } else if (current->key < X){

            current = current->droite;

        } else {

            return current;

        }

    }

    return NULL;

}

```



# Exercice (5-10min)



Écrire le code de la fonction



```C 

int tree_size(tree_t tree);

```



qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur

matrix.



Indication: la taille, est 1 + le nombre de nœuds du sous-arbre de gauche

additionné au nombre de nœuds dans le sous-arbre de droite.



. . .



```C

int arbre_size(tree_t tree) {

    if (NULL == tree) {

        return 0;

    } else {   

        return 1 + tree_size(tree->left) 

            + tree_size(tree->right);

    }

}

```



# L'insertion dans un arbre binaire



* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut

  pas construire l'arbre....



## Pour un arbre lexicographique



* Rechercher la position dans l'arbre où insérer.

* Créer un nœud avec la clé et le rattacher à l'arbre.



# Exemple d'insertions



* Clés uniques pour simplifier.

* Insertion de 5, 15, 10, 25, 2, -5, 12, 14, 11.

* Rappel:

    * Plus petit que la clé courante => gauche,

    * Plus grand que la clé courante => droite.

* Faisons le dessins ensemble



```



















```



## Exercice (3min, puis matrix)



* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5 





# Pseudo-code d'insertion (1/2)



* Deux parties:

    * Recherche le parent où se passe l'insertion.

    * Ajout du fils dans l'arbre.



## Recherche du parent



```

arbre position(arbre, clé)

    si est_non_vide(arbre)

        si clé < clé(arbre)

            suivant = gauche(arbre)

        sinon

            suivant = droite(arbre)

        tant que clé(arbre) != clé && est_non_vide(suivant)

            arbre = suivant

            si clé < clé(arbre)

                suivant = gauche(arbre)

            sinon

                suivant = droite(arbre)

            

    retourne arbre

```



# Pseudo-code d'insertion (2/2)



* Deux parties:

    * Recherche de la position.

    * Ajout dans l'arbre.



## Ajout du fils



```

ajout(arbre, clé)

    si est_vide(arbre)

        arbre = nœud(clé)

    sinon

        si clé < clé(arbre)

            gauche(arbre) = nœud(clé)

        sinon si clé > clé(arbre)

            droite(arbre) = nœud(clé)

        sinon

            retourne

```



# Code d'insertion en C (1/2)



## Recherche du parent (ensemble)



. . .



```C

tree_t position(tree_t tree, key_t key) {

    tree_t current = tree;

    if (NULL != current) {

        tree_t subtree = key > current->key ? current->right :

        current->left;

        while (key != current->key && NULL != subtree) {

            current = subtree;

            subtree = key > current->key ? current->right :

            current->left;

        }

    }

    return current;

}

```



[^1]: Copyright cours de mathématiques pendant trop d'années.

slides_2022/cours_16.md

0 → 100644
+1277 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_17.md

0 → 100644
+695 −0
Original line number Diff line number Diff line 
---

title: "Tri par tas et arbres AVL"

date: "2023-03-24"

---



# Questions sur les notions du dernier cours (1/2)



* Comment représenter un tableau sous forme d'arbre binaire?



. . .



* Qu'est-ce qu'un tas?



. . .



```

        | 1 | 16 | 5 | 12 | 4 | 2 | 8 | 10 | 6 | 7 |

```



* Quel est l'arbre que cela représente?





# Questions sur les notions du dernier cours (2/2)





```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((1))-->id1((16));

    id0-->id2((5));

    id1-->id3((12));

    id1-->id4((4));

    id2-->id5((2));

    id2-->id6((8));

    id3-->id7((10));

    id3-->id8((6));

    id4-->id9((7));

    id4-->id10(( ));    

    style id10 fill:#fff,stroke:#fff

```



# Exercice



* Trier par tas le tableau



```

        | 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16

```



* Mettez autant de détails que possible.

* Que constatez-vous?

* Postez le résultat sur matrix.



# L'algorithme du tri par tas (1/2)



\footnotesize



## Deux étapes



1. Entassement: transformer l'arbre en tas.

2. Échanger la racine avec le dernier élément et entasser la racine.



## Pseudo-code d'entassement de l'arbre (15 min, matrix)



. . .



```python

rien tri_par_tas(tab)

    entassement(tab)

    échanger(tab[0], tab[size(tab)-1])

    pour i de size(tab)-1 à 2 

        tamisage(tab, 0)

        échanger(tab[0], tab[i-1])



rien entassement(tab)

    pour i de size(tab)/2-1 à 0

        tamisage(tab, i)



rien tamisage(tab, i)

    ind_max = ind_max(tab, i, gauche(i), droite(i))

    si i != ind_max

        échanger(tab[i], tab[ind_max])

        tamisage(tab, ind_max)

```



# L'algorithme du tri par tas (2/2)



* Fonctions utilitaires



    ```python

    entier ind_max(tab, i, g, d)

        ind_max = i

        si tab[ind_max] < tab[g] && size(tab) > g

            ind_max = g

        si tab[ind_mx] < tab[d] && size(tab) > d

            ind_max = d

        retourne ind_max



    entier gauche(i)

        retourne 2 * i + 1

    

    entier droite(i)

        retourne 2 * i + 2

    ```





<!-- # L'algorithme du tri par tas (3/4)



\footnotesize



## Implémenter en C l'algorithme du tri par tas (matrix, 20min)



. . .



```C 

void heapsort(int size, int tab[size]) {

    heapify(size, tab);

    swap(tab, tab + size - 1);

    for (int s = size - 1; s > 1; s--) {

        sift_up(s, tab, 0);

        swap(tab, tab + s - 1);

    }

}

void heapify(int size, int tab[size]) {

    for (int i = size / 2 - 1; i >= 0; i--) {

        sift_up(size, tab, i);

    }

}

void sift_up(int size, int tab[size], int i) {

    int ind_max = ind_max3(size, tab, i, left(i), right(i));

    if (i != ind_max) {

        swap(tab + i, tab + ind_max);

        sift_up(size, tab, ind_max);

    }

}

```



# L'algorithme du tri par tas (4/4)



\footnotesize



## Fonctions utilitaires



. . .



```C

int ind_max3(int size, int tab[size], int i, int l, int r) {

    int ind_max = i;

    if (l < size && tab[ind_max] < tab[l]) {

        ind_max = l;

    }

    if (r < size && tab[ind_max] < tab[r]) {

        ind_max = r;

    }

    return ind_max;

}

void swap(int *a, int *b) {

    int tmp = *a;

    *a      = *b;

    *b      = tmp;

}

int left(int i) {

    return 2 * i + 1;

}

int right(int i) {

    return 2 * i + 2;

}

``` -->





# Complexités



::: columns



:::: column



## Complexité de la recherche



1. En moyenne?

2. Dans le pire des cas?



. . .



1. $O(\log_2(N))$

2. $O(N)$



::::



:::: column



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((10))-->id1((9));

    id0-->id8((  ));

    id1-->id2((7));

    id1-->id9((  ));

    id2-->id3((6));

    id2-->id10((  ));

    id3-->id4((5));

    id3-->id11((  ));

    style id8 fill:#fff,stroke:#fff

    style id9 fill:#fff,stroke:#fff

    style id10 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::



# Un meilleur arbre



* Quelle propriété doit satisfaire un arbre pour être $O(\log_2(N))$?



. . .



* Si on a environ le même nombre de nœuds dans les sous-arbres.



## Définition



Un arbre binaire est parfaitement équilibré si, pour chaque

nœud, la différence entre les nombres de nœuds des sous-

arbres gauche et droit vaut au plus 1.



* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.

* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?



. . .



* $O(\log_2(N))$.





# Équilibre parfait ou pas?



::: columns



:::: column



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((W))-->id1((B));

    id0-->id8((Y));

    id1-->id2((A));

    id1-->id9((  ));

    id8-->id10((X));

    id8-->id11((  ));

    style id9 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



```

É

Q

U

I

L

I

B

R

É

```



::::



:::



# Équilibre parfait ou pas?



::: columns



:::: column



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((16))-->id1((10));

    id0-->id2((19));

    id1-->id3((8));

    id1-->id4((12));

    id4-->id5((11));

    id4-->id6((  ));

    id2-->id7((17));

    id2-->id8((  ));

    id7-->id9((  ));

    id7-->id10((18));

    style id6 fill:#fff,stroke:#fff

    style id8 fill:#fff,stroke:#fff

    style id9 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



```

P 

A

S 



É

Q

U

I

L

I

B

R

É

```



::::



:::



# Arbres AVL



\footnotesize



* Quand est-ce qu'on équilibre un arbre?



. . .



* A l'insertion/suppression.

* Maintenir un arbre en état d'équilibre parfait: cher (insertion, suppression).

* On peut "relaxer" la condition d'équilibre: profondeur (hauteur) au lieu du

  nombre de nœuds:

    * La hauteur $\sim\log_2(N)$.



## Définition



Un arbre AVL (Adelson-Velskii et Landis) est un arbre binaire de recherche dans

lequel, pour chaque nœud, la différence de hauteur entre le sous-arbre gauche et droit vaut au plus 1.



* Relation entre nœuds et hauteur:

$$

\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.

$$

* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.



# Notation



* `hg`: hauteur du sous-arbre gauche.

* `hd`: hauteur du sous-arbre droit.

* `facteur d'équilibre = fe = hd - hg`

* Que vaut `fe` si l'arbre est AVL?



. . .



* `fe = {-1, 0, 1}`





# AVL ou pas?



::: columns



:::: column



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((10));

    id0-->id2((19));

    id2-->id3((17));

    id2-->id4((97));

```



::::



:::: column



. . .



```

A

V

L

```



::::



:::



# AVL ou pas?



::: columns



:::: column



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id2-->id3((17));

    id2-->id4((97));

    id4-->id5((37));

    id4-->id6((  ));

    style id6 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



```

P

A

S



A

V

L

```



::::



:::



# Insertion dans un arbre AVL (1/N)



1. On part d'un arbre AVL.

2. On insère un nouvel élément.



::: columns



:::: column



* `hd ? hg`.

* Insertion de `4`?



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

```



::::



:::: column



. . .



* `hd = hg`



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id1-->id4((  ));

    id1-->id5((4));

    style id4 fill:#fff,stroke:#fff

```



* `fe = -1`



::::



:::



# Insertion dans un arbre AVL (2/N)



1. On part d'un arbre AVL.

2. On insère un nouvel élément.



::: columns



:::: column



* `hd ? hg`.

* Insertion de `4`?



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id2-->id3((18));

    id2-->id4((  ));

    style id4 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



* `hd < hg`



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id2-->id3((18));

    id2-->id4((  ));

    id1-->id5((  ));

    id1-->id6((4));

    style id4 fill:#fff,stroke:#fff

    style id5 fill:#fff,stroke:#fff

```



* `fe = 0`



::::



:::



# Insertion dans un arbre AVL (3/N)



\footnotesize



1. On part d'un arbre AVL.

2. On insère un nouvel élément.



::: columns



:::: column



* `hd ? hg`.

* Insertion de `4`?



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id1-->id3((  ));

    id1-->id4((6));

    id2-->id5((  ));

    id2-->id6((  ));

    style id3 fill:#fff,stroke:#fff

    style id5 fill:#fff,stroke:#fff

    style id6 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



* `hd < hg`



```{.mermaid format=pdf width=400 loc=figs/}

graph TD;

    id0((12))-->id1((1));

    id0-->id2((19));

    id1-->id3((  ));

    id1-->id4((6));

    id4-->id5((4));

    id4-->id6((  ));

    id2-->id7((  ));

    id2-->id8((  ));

    style id3 fill:#fff,stroke:#fff

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

    style id8 fill:#fff,stroke:#fff

```



::::



:::



**Déséquilibre!** Que vaut `fe`?



. . .



* `fe = 2`



# Les cas de déséquilibre





::: columns



:::: column



## Cas 1a



* `u`, `v`, `w` même hauteur.

* déséquilibre en `B` après insertion dans `u`



![Après insertion](figs/cas1a_gauche.png)



::::



:::: column



## Cas 1a



* Comment rééquilibrer?



. . .



* ramène `u`, `v` `w` à la même hauteur.

* `v` à droite de `A` (gauche de `B`)



![Après équilibrage](figs/cas1a_droite.png)



::::



:::



# Les cas de déséquilibre





::: columns



:::: column



## Cas 1b (symétrique 1a)



![Après insertion](figs/cas1b_gauche.png)



::::



:::: column



## Cas 1b (symétrique 1a)



* Comment rééquilibrer?



. . .



![Après équilibrage](figs/cas1b_droite.png)



::::



:::



# Les cas de déséquilibre





::: columns



:::: column



## Cas 2a



* `h(v1)=h(v2), h(u)=h(w)`.

* déséquilibre en `C` après insertion dans `v2`



![Après insertion](figs/cas2a_gauche.png)



::::



:::: column



## Cas 2a



* Comment rééquilibrer?



. . .



* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).

* `v2` à droite de `B` (gauche de `C`)

* `B` à droite de `A` (gauche de `C`)

* `v1` à droite de `A` (gauche de `B`)



![Après équilibrage](figs/cas2a_droite.png)



::::



:::





# Les cas de déséquilibre





::: columns



:::: column



## Cas 2b (symétrique 2a)



![Après insertion](figs/cas2b_gauche.png)



::::



:::: column



## Cas 2b (symétrique 2a)



* Comment rééquilibrer?



. . .



![Après équilibrage](figs/cas2b_droite.png)



::::



:::

slides_2022/cours_18.md

0 → 100644
+947 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_19.md

0 → 100644
+488 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_20.md

0 → 100644
+795 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_21.md

0 → 100644
+731 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_22.md

0 → 100644
+351 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_23.md

0 → 100644
+1013 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_24.md

0 → 100644
+709 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2022/cours_25.md

0 → 100644
+1077 −0

File added.

Preview size limit exceeded, changes collapsed.

slides/cours_5.md→slides_2022/cours_5.md

+1 −1
Original line number Diff line number Diff line
@@ -26,7 +26,7 @@ date: "2022-11-02" 


    ```C

    enum days d = monday;

    (d + 2) == tuesday + tuesday; // true

    (d + 2) == monday + monday; // true

    ```



# Types énumérés (2/2)

slides_2022/docker-compose.yml

0 → 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_2022/figs/composantes_fortement_connexes.svg

0 → 100644
+14 −0
Original line number Diff line number Diff line 
<svg width="201mm" height="95mm" version="1.1" viewBox="0 0 201 95" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">

 <rect width="201" height="95" fill="#fff"/>

 <g transform="translate(-3-3)" stroke-width="1.5" stroke="#000">

 <path d="m103.3 61c-56.6 .4-56.2 34.2 0 34 56.2 0 56.6-33.7 0-34z" fill="#eef" stroke-dasharray="1.5"/>

 <g id="c"><path d="m6 5.7 0 89.3c46-.4 86-55.8 85.8-89.3z" fill="#eef" stroke-dasharray="1.5"/><g fill="#fff"><circle cx="18" cy="21.6" r="9.4"/><circle cx="74.6" cy="78" r="9.4"/><circle cx="74.6" cy="21.6" r="9.4"/><circle cx="18" cy="78.2" r="9.4"/></g>

 <use transform="rotate(90 74.6 78.2)" xlink:href="#a"/><path d="m27.4 78.2h29.5"/>

 <path id="a" d="m50.3 71.5 3.3 6.7-3.3 6.7 13.4-6.7z" stroke="none" fill="#000"/><path d="m74.6 31 0 29.6"/></g>

 <use transform="translate(0-56.6)" xlink:href="#a"/><use transform="rotate(-90 17.5 77.6)" xlink:href="#a"/><use transform="rotate(135 46 66.8)" xlink:href="#a"/><use transform="matrix(-1 0 0 1 207 0)" xlink:href="#c"/><use transform="translate(57.8-56.6)" xlink:href="#a"/>

 <g id="b" fill="none"><use transform="rotate(133 74.8 82)" stroke="none" xlink:href="#a"/><path d="m88.7 72.7c8-8.7 19.2-10 34.3 5.5"/>

 <g transform="rotate(180 104 77.4)"><use transform="rotate(133.4 74.8 82)" stroke="none" xlink:href="#a"/><path d="m88.6 73c9-10.3 17.7-9.7 34.4 5"/></g></g>

 <use transform="translate(56.4-55)" xlink:href="#b"/><use transform="rotate(-90 131.8 22.2)" xlink:href="#b"/>

 <g fill="none"><path d="m27.4 21.6 29.5 0"/><path d="m18 69v-30.7"/><path d="m68 28.4-38.5 38"/><path d="m84 21.6h30.8"/></g>

 <g style="font-family:'Arial';-inkscape-font-specification:'Arial'" font-weight="bold" text-anchor="middle" font-size="12px" stroke="none"><text x="18" y="24.7">a</text><text x="74.4" y="26">b</text><text x="132" y="24.7">c</text><text x="189" y="24.7">d</text><text x="18" y="81.3">e</text>

 <text x="74.3" y="82.6">f</text><text x="132.5" y="80">g</text><text x="188.8" y="82.5">h</text></g></g></svg>
 
 No newline at end of file