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
1000 files
+ 187890
− 1000
Compare changes
  • Side-by-side
  • Inline

Files

.gitignore

+5 −0
Original line number Diff line number Diff line 
*.o

*.xopp*

slides/package-lock.json

slides/package.json

slides/.vscode/settings.json

.vscode/settings.json

slides/node_modules/.package-lock.json

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

css/tufte-css/tufte.css

0 → 100644
+470 −0
Original line number Diff line number Diff line 
@charset "UTF-8";



/* Import ET Book styles

   adapted from https://github.com/edwardtufte/et-book/blob/gh-pages/et-book.css */



@font-face {

    font-family: "et-book";

    src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot");

    src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.woff") format("woff"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.ttf") format("truetype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.svg#etbookromanosf") format("svg");

    font-weight: normal;

    font-style: normal;

    font-display: swap;

}



@font-face {

    font-family: "et-book";

    src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot");

    src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.woff") format("woff"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.ttf") format("truetype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.svg#etbookromanosf") format("svg");

    font-weight: normal;

    font-style: italic;

    font-display: swap;

}



@font-face {

    font-family: "et-book";

    src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot");

    src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.woff") format("woff"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.ttf") format("truetype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.svg#etbookromanosf") format("svg");

    font-weight: bold;

    font-style: normal;

    font-display: swap;

}



@font-face {

    font-family: "et-book-roman-old-style";

    src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot");

    src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.woff") format("woff"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.ttf") format("truetype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.svg#etbookromanosf") format("svg");

    font-weight: normal;

    font-style: normal;

    font-display: swap;

}



/* Tufte CSS styles */

html {

    font-size: 15px;

}



body {

    width: 87.5%;

    margin-left: auto;

    margin-right: auto;

    padding-left: 12.5%;

    font-family: et-book, Palatino, "Palatino Linotype", "Palatino LT STD", "Book Antiqua", Georgia, serif;

    background-color: #fffff8;

    color: #111;

    max-width: 1400px;

    counter-reset: sidenote-counter;

}



h1 {

    font-weight: 400;

    margin-top: 4rem;

    margin-bottom: 1.5rem;

    font-size: 3.2rem;

    line-height: 1;

}



h2 {

    font-style: italic;

    font-weight: 400;

    margin-top: 2.1rem;

    margin-bottom: 1.4rem;

    font-size: 2.2rem;

    line-height: 1;

}



h3 {

    font-style: italic;

    font-weight: 400;

    font-size: 1.7rem;

    margin-top: 2rem;

    margin-bottom: 1.4rem;

    line-height: 1;

}



hr {

    display: block;

    height: 1px;

    width: 55%;

    border: 0;

    border-top: 1px solid #ccc;

    margin: 1em 0;

    padding: 0;

}



p.subtitle {

    font-style: italic;

    margin-top: 1rem;

    margin-bottom: 1rem;

    font-size: 1.8rem;

    display: block;

    line-height: 1;

}



.numeral {

    font-family: et-book-roman-old-style;

}



.danger {

    color: red;

}



article {

    padding: 5rem 0rem;

}



section {

    padding-top: 1rem;

    padding-bottom: 1rem;

}



p,

dl,

ol,

ul {

    font-size: 1.4rem;

    line-height: 2rem;

}



p {

    margin-top: 1.4rem;

    margin-bottom: 1.4rem;

    padding-right: 0;

    vertical-align: baseline;

}



/* Chapter Epigraphs */

div.epigraph {

    margin: 5em 0;

}



div.epigraph > blockquote {

    margin-top: 3em;

    margin-bottom: 3em;

}



div.epigraph > blockquote,

div.epigraph > blockquote > p {

    font-style: italic;

}



div.epigraph > blockquote > footer {

    font-style: normal;

}



div.epigraph > blockquote > footer > cite {

    font-style: italic;

}

/* end chapter epigraphs styles */



blockquote {

    font-size: 1.4rem;

}



blockquote p {

    width: 55%;

    margin-right: 40px;

}



blockquote footer {

    width: 55%;

    font-size: 1.1rem;

    text-align: right;

}



section > p,

section > footer,

section > table {

    width: 55%;

}



/* 50 + 5 == 55, to be the same width as paragraph */

section > dl,

section > ol,

section > ul {

    width: 50%;

    -webkit-padding-start: 5%;

}



dt:not(:first-child),

li:not(:first-child) {

    margin-top: 0.25rem;

}



figure {

    padding: 0;

    border: 0;

    font-size: 100%;

    font: inherit;

    vertical-align: baseline;

    max-width: 55%;

    -webkit-margin-start: 0;

    -webkit-margin-end: 0;

    margin: 0 0 3em 0;

}



figcaption {

    float: right;

    clear: right;

    margin-top: 0;

    margin-bottom: 0;

    font-size: 1.1rem;

    line-height: 1.6;

    vertical-align: baseline;

    position: relative;

    max-width: 40%;

}



figure.fullwidth figcaption {

    margin-right: 24%;

}



/* Links: replicate underline that clears descenders */

a:link,

a:visited {

    color: inherit;

}



.no-tufte-underline:link {

    background: unset;

    text-shadow: unset;

}



a:link, .tufte-underline, .hover-tufte-underline:hover {

    text-decoration: none;

    background: -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(currentColor, currentColor);

    background: linear-gradient(#fffff8, #fffff8), linear-gradient(#fffff8, #fffff8), linear-gradient(currentColor, currentColor);

    -webkit-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;

    -moz-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;

    background-size: 0.05em 1px, 0.05em 1px, 1px 1px;

    background-repeat: no-repeat, no-repeat, repeat-x;

    text-shadow: 0.03em 0 #fffff8, -0.03em 0 #fffff8, 0 0.03em #fffff8, 0 -0.03em #fffff8, 0.06em 0 #fffff8, -0.06em 0 #fffff8, 0.09em 0 #fffff8, -0.09em 0 #fffff8, 0.12em 0 #fffff8, -0.12em 0 #fffff8, 0.15em 0 #fffff8, -0.15em 0 #fffff8;

    background-position: 0% 93%, 100% 93%, 0% 93%;

}



@media screen and (-webkit-min-device-pixel-ratio: 0) {

    a:link, .tufte-underline, .hover-tufte-underline:hover {

        background-position-y: 87%, 87%, 87%;

    }

}



a:link::selection,

a:link::-moz-selection {

    text-shadow: 0.03em 0 #b4d5fe, -0.03em 0 #b4d5fe, 0 0.03em #b4d5fe, 0 -0.03em #b4d5fe, 0.06em 0 #b4d5fe, -0.06em 0 #b4d5fe, 0.09em 0 #b4d5fe, -0.09em 0 #b4d5fe, 0.12em 0 #b4d5fe, -0.12em 0 #b4d5fe, 0.15em 0 #b4d5fe, -0.15em 0 #b4d5fe;

    background: #b4d5fe;

}



/* Sidenotes, margin notes, figures, captions */

img {

    max-width: 100%;

}



.sidenote,

.marginnote {

    float: right;

    clear: right;

    margin-right: -60%;

    width: 50%;

    margin-top: 0.3rem;

    margin-bottom: 0;

    font-size: 1.1rem;

    line-height: 1.3;

    vertical-align: baseline;

    position: relative;

}



.sidenote-number {

    counter-increment: sidenote-counter;

}



.sidenote-number:after,

.sidenote:before {

    font-family: et-book-roman-old-style;

    position: relative;

    vertical-align: baseline;

}



.sidenote-number:after {

    content: counter(sidenote-counter);

    font-size: 1rem;

    top: -0.5rem;

    left: 0.1rem;

}



.sidenote:before {

    content: counter(sidenote-counter) " ";

    font-size: 1rem;

    top: -0.5rem;

}



blockquote .sidenote,

blockquote .marginnote {

    margin-right: -82%;

    min-width: 59%;

    text-align: left;

}



div.fullwidth,

table.fullwidth {

    width: 100%;

}



div.table-wrapper {

    overflow-x: auto;

    font-family: "Trebuchet MS", "Gill Sans", "Gill Sans MT", sans-serif;

}



.sans {

    font-family: "Gill Sans", "Gill Sans MT", Calibri, sans-serif;

    letter-spacing: .03em;

}



code, pre > code {

    font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;

    font-size: 1.0rem;

    line-height: 1.42;

    -webkit-text-size-adjust: 100%; /* Prevent adjustments of font size after orientation changes in iOS. See https://github.com/edwardtufte/tufte-css/issues/81#issuecomment-261953409 */

}



.sans > code {

    font-size: 1.2rem;

}



h1 > code,

h2 > code,

h3 > code {

    font-size: 0.80em;

}



.marginnote > code,

.sidenote > code {

    font-size: 1rem;

}



pre > code {

    font-size: 0.9rem;

    width: 52.5%;

    margin-left: 2.5%;

    overflow-x: auto;

    display: block;

}



pre.fullwidth > code {

    width: 90%;

}



.fullwidth {

    max-width: 90%;

    clear:both;

}



span.newthought {

    font-variant: small-caps;

    font-size: 1.2em;

}



input.margin-toggle {

    display: none;

}



label.sidenote-number {

    display: inline;

}



label.margin-toggle:not(.sidenote-number) {

    display: none;

}



.iframe-wrapper {

    position: relative;

    padding-bottom: 56.25%; /* 16:9 */

    padding-top: 25px;

    height: 0;

}



.iframe-wrapper iframe {

    position: absolute;

    top: 0;

    left: 0;

    width: 100%;

    height: 100%;

}



@media (max-width: 760px) {

    body {

        width: 84%;

        padding-left: 8%;

        padding-right: 8%;

    }



    hr,

    section > p,

    section > footer,

    section > table {

        width: 100%;

    }



    pre > code {

        width: 97%;

    }



    section > dl,

    section > ol,

    section > ul {

        width: 90%;

    }



    figure {

        max-width: 90%;

    }



    figcaption,

    figure.fullwidth figcaption {

        margin-right: 0%;

        max-width: none;

    }



    blockquote {

        margin-left: 1.5em;

        margin-right: 0em;

    }



    blockquote p,

    blockquote footer {

        width: 100%;

    }



    label.margin-toggle:not(.sidenote-number) {

        display: inline;

    }



    .sidenote,

    .marginnote {

        display: none;

    }



    .margin-toggle:checked + .sidenote,

    .margin-toggle:checked + .marginnote {

        display: block;

        float: left;

        left: 1rem;

        clear: both;

        width: 95%;

        margin: 1rem 2.5%;

        vertical-align: baseline;

        position: relative;

    }



    label {

        cursor: pointer;

    }



    div.table-wrapper,

    table {

        width: 85%;

    }



    img {

        width: 100%;

    }

}

slides/.gitignore

+1 −4
Original line number Diff line number Diff line 
*.pdf

*.json

*.err
 
*.markdown

*.html

index.md

.puppeteer.json

slides/Makefile

+14 −22
Original line number Diff line number Diff line
@@ -8,46 +8,37 @@ 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

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

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



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

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)



index:

	rm -f index.md

	./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 $@ $^



%.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
@@ -60,11 +51,12 @@ 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 

deploy: all index.html

	mkdir -p algo_cours

	cp *.pdf algo_cours

	cp index.html algo_cours



clean:

	rm -f *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json

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



.PHONY:	clean index puppeteer yq
 
.PHONY:	clean index.md puppeteer yq

slides/cours_1.md

+19 −363
Original line number Diff line number Diff line 
---

title: "Introduction aux algorithmes"

date: "2021-09-22"

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;
@@ -57,14 +57,12 @@ Nombre premier: nombre possédant deux diviseurs entiers distincts. 
## Algorithme naïf (problème)



```C

est_premier(nombre) {

    si {

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

booléen est_premier(nombre) 

    si 

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

            i ne divise pas nombre

        }

    } alors vrai

    alors vrai

    sinon faux

}

```



. . .
@@ -80,14 +78,12 @@ est_premier(nombre) { 
## Algorithme naïf (une solution)



```C

est_premier(nombre) { // fonction

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

    tant que i < nombre { // boucle

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

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

    }

        i = i + 1

    retourne vrai // expression typée

```
@@ -103,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;

}
@@ -125,9 +121,9 @@ 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 -fsanitize=address 

    -fsanitize=leak -fsanitize=undefined

    ```console

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

    	-fsanitize=address 

    ```

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

    2. `-Wall et -Wextra` activation des warnings.
@@ -244,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)
@@ -292,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
@@ -336,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
@@ -351,343 +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");

}

```



# Exercice: la factorielle



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un pseudo-code



. . .



```C

int factorielle(int n) {

    i = 1;

    fact = 1;

    pour i <= n {

        fact *= i;

        i += 1;

    }

}

```



# Exercice: la factorielle



\footnotesize



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un code en C



Quand vous avez fini postez le code sur le salon matrix.



. . .



```C

#include <stdio.h>

int main() {

   int nb = 10;

   int fact = 1;

   int iter = 2;

   while (iter <= nb) {

      fact *= iter;

      iter++;

   }

}

```



. . .



## Comment améliorer ce code? (notez ça sur une feuille)





# Entrées/sorties: `printf()`{.C} (1/2)



## Généralités



- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:



    ```C

    int printf(const char *format, ...);

    ```

- Nombre d'arguments variables.

- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.

- Les arguments suivants sont les expressions à afficher.



# Entrées/sorties: `printf()`{.C} (2/2)



## Exemple



```C

#include <stdio.h>

#include <stdlib.h>



int main() {

    printf("Hello world.\n");

    int val = 1;

    printf("Hello world %d time.\n", val);

    printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);

    return EXIT_SUCCESS;

}

```



# Entrées/sorties: `scanf()`{.C} (1/2)



## Généralités



- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:



    ```C

    int scanf(const char *format, ...);

    ```



- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).

- Les arguments suivants sont les variables où sont stockées les valeurs lues.



# Entrées/sorties: `scanf()`{.C} (2/2)



## Exemple



```C

#include <stdio.h>

#include <stdlib.h>



int main() {

    printf("Enter 3 numbers: \n");

    int i, j, k;

    scanf("%d %d %d", &i, &j, &k);

    printf("You entered: %d %d %d\n", i, j, k);

    

    return EXIT_SUCCESS;

}

```



# Exercice: la factorielle en mieux



## Individuellement



1. Ajoutez des fonctionnalités à votre code.

2. Écrivez l'algorithme de calcul de deux façon différentes.

3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le 

   en récursif (sans aide).



. . .



## Postez vos solutions sur matrix!

slides/cours_2.md

+302 −159
Original line number Diff line number Diff line 
---

title: "Introduction aux algorithmes"

date: "2021-09-29"

title: "Introduction aux algorithmes II"

date: "2025-09-23"

---



# Rappel



* Quel est l'algorithme pour le calcul des nombres 1ers?



. . .



```C

bool est_premier(int nombre) {

    int i = 2; // bonne pratique!

    while (i < nombre) { // penser à bien indenter!

        if (0 == nombre % i) { // ça rend le code LISIBLE!

            return false;

        }

        i += 1;

    }

    return true;

}

```



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



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





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

}

```





# Exercice: la factorielle



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un pseudo-code



. . .



```python

entier factorielle(entier n)

    i = 1

    fact = 1

    tant que i <= n

        fact *= i

        i += 1

    retourne fact

```



# Exercice: la factorielle



\footnotesize



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un code en C



Quand vous avez fini postez le code sur le salon matrix.



. . .



```C

#include <stdio.h>

int main() {

   int nb = 10;

   int fact = 1;

   int iter = 2;

   while (iter <= nb) {

      fact *= iter;

      iter++;

   }

   printf("La factorielle de %d est %d\n", nb, fact);

}

```



. . .



## Comment améliorer ce code? (notez ça sur une feuille)





# Exercice: la factorielle en mieux



## Individuellement



1. Écrivez l'algorithme de calcul de deux façon différentes.

2. Que se passe-t-il si $n>=15$?

3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le 

   en récursif (sans aide).



. . .



## Postez vos solutions sur **matrix**!



# Exercice: test si un nombre est premier



## Avec tout ce que vous avez appris la dernière fois:

## Avec tout ce que vous avez appris jusqu'ici:



* Écrivez le code testant si un nombre est premier.

* Quels sont les ajouts possibles par rapport au code de la semaine passée?
@@ -159,12 +457,6 @@ Par groupe de 3 (5-10min): 
Si un nombre, `p`, est multiple de `a` et de `b` alors il peut s'écrire `p = a

* i = b * j`  ou encore `p / a = i` et `p / b = j`.



<!-- Si un nombre, $p$, est multiple de $a$ et de $b$ alors il peut s'écrire -->

<!-- $$ -->

<!-- p = a \cdot i = b \cdot j, -->

<!-- $$ -->

<!-- ou encore $p / a = i$ et $p / b = j$. -->



. . .



## Pseudo-code
@@ -172,7 +464,7 @@ Si un nombre, `p`, est multiple de `a` et de `b` alors il peut s'écrire `p = a 
```C

int ppcm(int a, int b) {

    for (i in [1, b]) {

        if a * i is divisible by b {

        if a * i est divisible par b {

            return a * i

        }

    }
@@ -191,7 +483,6 @@ int ppcm(int a, int b) { 
```C

#include <stdio.h>

#include <stdlib.h> 



int main() { 

   int n = 15, m = 12;

   int i = 1;
@@ -209,7 +500,6 @@ int main() { 
```C

#include <stdio.h>

#include <stdlib.h> 



int main() { 

   int res = n*m;

   for (int i = 2; i <= m; i++) {
@@ -222,153 +512,6 @@ int main() { 
}

```



# Le calcul du PGCD (1/5)



## Définition



Le plus grand commun diviseur (PGCD) de deux nombres entiers non nuls est le

plus grand entier qui les divise en même temps. 



## Exemples:



```C

PGCD(3, 4) = 1,

PGCD(4, 6) = 2,

PGCD(5, 15) = 5.

```



. . .



## Mathématiquement



Décomposition en nombres premiers:



$$

36 = 2^2\cdot 3^2,\quad 90=2\cdot 5\cdot 3^2,

$$

On garde tous les premiers à la puissance la plus basse

$$

PGCD(36, 90)=2^{\min{1,2}}\cdot 3^{\min{2,2}}\cdot 5^{\min{0,1}}=18.

$$



# Le calcul du PGCD (2/5)



## Algorithme



Par groupe de 3 (5-10min):



* réfléchissez à un algorithme alternatif donnant le PGCD de deux nombres;

* écrivez l'algorithme en pseudo-code.



. . .



## Exemple d'algorithme



```C

PGCD(36, 90):

90 % 36 != 0 // otherwise 36 would be PGCD

90 % 35 != 0 // otherwise 35 would be PGCD

90 % 34 != 0 // otherwise 34 would be PGCD

...

90 % 19 != 0 // otherwise 19 would be PGCD

90 % 18 == 0 // The end!

```



* 18 modulos, 18 assignations, et 18 comparaisons.



# Le calcul du PGCD (3/5)



## Transcrivez cet exemple en algorithme (groupe de 3) et codez-le (5-10min)!



. . .



## Optimisation



* Combien d'additions / comparaisons au pire?

* Un moyen de le rendre plus efficace?



. . .



## Tentative de correction



```C

void main() {

   int n = 90, m = 78;

   int gcd = 1;

   for (int div = n; div >= 2; div--) { // div = m, sqrt(n)

      if (n % div == 0 && m % div == 0) {

         gcd = div;

         break;

      }

   }

   printf("Le pgcd de %d et %d est %d\n", n, m, gcd);

}

```



# Le calcul du PGCD (4/5)



## Réusinage: l'algorithme d'Euclide



`Dividende = Diviseur * Quotient + Reste`



```C

PGCD(35, 60):

35 = 60 * 0 + 35 // 60 -> 35, 35 -> 60

60 = 35 * 1 + 25 // 35 -> 60, 25 -> 35

35 = 25 * 1 + 10 // 25 -> 35, 20 -> 25

25 = 10 * 2 +  5 // 10 -> 25, 5  -> 10

10 =  5 * 2 +  0 // PGCD = 5!

```



. . .



## Algorithme



Par groupe de 3 (5-10min):



* analysez l'exemple ci-dessus;

* transcrivez le en pseudo-code.



# Le calcul du PGCD (5/5)



## Pseudo-code



```C

int pgcd(int a, int b) {

    tmp_n = n

    tmp_m = m

    while (tmp_m does not divide tmp_n) {

        tmp   = tmp_n

        tmp_n = tmp_m

        tmp_m = tmp modulo tmp_m

    }

    return tmp_m

}

```



# Le code du PGCD de 2 nombres



## Implémentez le pseudo-code et postez le code sur matrix (5min).



. . .



## Un corrigé possible



```C

#include <stdio.h>

void main() {

   int n = 90;

   int m = 78;

   printf("n = %d et m = %d\n", n, m);

   int tmp_n = n;

   int tmp_m = m;

   while (tmp_n%tmp_m > 0) {

      int tmp = tmp_n;

      tmp_n = tmp_m;

      tmp_m = tmp % tmp_m;

   }

   printf("Le pgcd de %d et %d est %d\n", n, m, tmp_m);

}

```

slides/docker-compose.yml

+2 −6
Original line number Diff line number Diff line 
version: "3.3"

services:

    slides:

        #To use dockerfile : build: . 

        image:  omalaspinas/pandoc:latest

        environment:

            USER: 1000

            GROUP: 1000

        user: 1000:1000

        container_name: slides

        volumes:

            - ./:/data

        # entrypoint: ["make", "all"]

        entrypoint: ["make"]

        working_dir: /data
 
        # user: "$(id -u):$(id -g)"

slides/gen_index.sh

+34 −22
Original line number Diff line number Diff line 
#!/bin/bash



set -e



function get_info() {

    local field=$(echo "$fullName" | sed "$2q;d" $1);

    IFS=$3;

    local field=($field); 

    if [ "${field}" != $5 ]; then

        return 1

    fi

    local field=${field[1]};

    IFS=$4;

    local field=($field);

    local field=${field[1]};

    echo "$field"

}



function fail() {

    printf '%s\n' "$1" >&2 ## Send message to stderr.

    exit "${2-1}" ## Return a code specified by $2, or 1 by default.

}



OIFS=$IFS

NUM_LINE=2

PREFIX=""
@@ -8,36 +29,27 @@ PREFIX="" 
classes=()

for i in *.md; do

    [ -f "$i" ] || break

    comp=$(echo "$fullName" | sed "${NUM_LINE}q;d" $i)

    date=$(echo "$fullName" | sed "3q;d" $i)

    IFS=':' 

    comp=($comp); 

    comp=${comp[1]}

    date=($date); 

    date=${date[1]}

    # echo $comp

    IFS='"'

    comp=($comp)

    comp=${comp[1]}

    date=($date); 

    date=${date[1]}

    # echo $comp | awk '{ print substr( $0, 1, length($0)-1 ) }'

    # echo $comp

    # date=sed "${NUM_LINE}q;d" $i

    date="$(get_info $i 3 ":" '"' "date")"

    if [ "$date" == 1 ]; then

        fail "Error date field not found"

    fi

    comp="$(get_info $i 2 ":" '"' "title")"

    if [ "$comp" == 1 ]; then

        fail "Error title field not found"

    fi

    i="${i%.*}"

    class="[${date} ${comp}](${PREFIX}${i}.pdf)"

    classes+=($class)

    # echo "[${date} ${comp}](${PREFIX}${i}.pdf)" >> index.md

    class="[${date}: ${comp}](${PREFIX}${i}.pdf)"

    classes+=("$class")

done

IFS=$'\n'

classes=($(sort <<<"${classes[*]}"))

date=$(date '+%Y-%m-%d')

echo "---" >> index.md

echo "title: Slides du cours d'Algorithmique" >> index.md

echo "date: ${date}" >> index.md

echo "title: \"Slides du cours d'algorithmique\"" >> index.md

echo "date: \"${date}\"" >> index.md

echo "---" >> index.md

echo "" >> index.md

echo "# Tous les slides du cours d'Algorithmique" >> index.md

echo "# Tous les slides du cours d'algorithmique" >> index.md

echo "" >> index.md

for i in ${classes[*]}; do

    echo "* $i" >> index.md

slides/intro.md

+21 −38
Original line number Diff line number Diff line 
---

title: "Introduction générale"

date: "2020-09-16"

date: "2025-09-16"

---



# La hotline
@@ -11,59 +11,42 @@ Paul Albuquerque paul.albuquerque@hesge.ch B410 
Orestis Malaspinas     orestis.malaspinas@hesge.ch       A401

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



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

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



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



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

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



# Cyberlearn



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_2020_21

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

  - Clé d'inscription: algo_2025_26



- Programmation séquentielle en C

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

  - Clé d'inscription: prog_seq_2025_26



- Programmation Sequentielle en C

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

  - Clé d'inscription: PS_2018



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

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 "petits" exercices illustrant les concepts d'algorithmique 

      (1-2 séances).

    * Évaluations:

        * Un projet de programmation.

        * Une évaluation machine.



# Sondage: expérience de programmation



## [Sondage: expérience de linux](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1291283)



## [Sondage: expérience de programmation](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1035242)



**Installez un lecteur de QR code s'il-vous-plaît.**



# Questions?



- N'hésitez pas à poser des *questions*, nous sommes là pour ça! [^1]

- Ne restez pas coincés pendant des jours sur un problème.

- Utilisez le *libre-service*!

- N'hésitez pas à faire des *retours*: *négatifs* ou *positifs*.



[^1]: Chaque étudiant·e·s a un quota de 5 questions par semestre.

    * Plusieurs exercices illustrant les concepts d'algorithmique.

    * É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, 2021-2022"

author: "Paul Albuquerque (B410), Pierre Künzli et Orestis 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_2021/.gitignore

0 → 100644
+6 −0
Original line number Diff line number Diff line 
*.pdf

*.err

*.markdown

*.html

index.md

.puppeteer.json

slides_2021/Makefile

0 → 100644
+71 −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



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

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 make puppeteer -k || true

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



docker_clean: docker-compose.yml

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



puppeteer:

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

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



index:

	rm -f index.md

	./gen_index.sh



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

	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 

	mkdir -p algo_cours

	cp *.pdf algo_cours



clean:

	rm -f *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json



.PHONY:	clean index puppeteer yq

slides_2021/cours_1.md

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

title: "Introduction aux algorithmes"

date: "2021-09-22"

---



# 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

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

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 

    -fsanitize=leak -fsanitize=undefined

    ```

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

}

```



# Exercice: la factorielle



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un pseudo-code



. . .



```C

int factorielle(int n) {

    i = 1;

    fact = 1;

    pour i <= n {

        fact *= i;

        i += 1;

    }

}

```



# Exercice: la factorielle



\footnotesize



Écrire un programme qui calcule la factorielle d'un nombre

$$

N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.

$$



## Par groupe de 3: écrire un code en C



Quand vous avez fini postez le code sur le salon matrix.



. . .



```C

#include <stdio.h>

int main() {

   int nb = 10;

   int fact = 1;

   int iter = 2;

   while (iter <= nb) {

      fact *= iter;

      iter++;

   }

}

```



. . .



## Comment améliorer ce code? (notez ça sur une feuille)





# Entrées/sorties: `printf()`{.C} (1/2)



## Généralités



- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:



    ```C

    int printf(const char *format, ...);

    ```

- Nombre d'arguments variables.

- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.

- Les arguments suivants sont les expressions à afficher.



# Entrées/sorties: `printf()`{.C} (2/2)



## Exemple



```C

#include <stdio.h>

#include <stdlib.h>



int main() {

    printf("Hello world.\n");

    int val = 1;

    printf("Hello world %d time.\n", val);

    printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);

    return EXIT_SUCCESS;

}

```



# Entrées/sorties: `scanf()`{.C} (1/2)



## Généralités



- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:



    ```C

    int scanf(const char *format, ...);

    ```



- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).

- Les arguments suivants sont les variables où sont stockées les valeurs lues.



# Entrées/sorties: `scanf()`{.C} (2/2)



## Exemple



```C

#include <stdio.h>

#include <stdlib.h>



int main() {

    printf("Enter 3 numbers: \n");

    int i, j, k;

    scanf("%d %d %d", &i, &j, &k);

    printf("You entered: %d %d %d\n", i, j, k);

    

    return EXIT_SUCCESS;

}

```



# Exercice: la factorielle en mieux



## Individuellement



1. Ajoutez des fonctionnalités à votre code.

2. Écrivez l'algorithme de calcul de deux façon différentes.

3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le 

   en récursif (sans aide).



. . .



## Postez vos solutions sur matrix!

slides/cours_16.md→slides_2021/cours_16.md

+4 −1
Original line number Diff line number Diff line
@@ -270,9 +270,10 @@ arbre suppression(arbre, clé) 
```



# Il nous manque le code pour le `parent`



## Pseudo-code pour trouver le parent (5min -> matrix)



. . .



```

arbre parent(arbre, sous_arbre)

    si est_non_vide(arbre)
@@ -296,6 +297,8 @@ arbre parent(arbre, sous_arbre) 


## Pour un seul enfant (5min -> matrix)



. . .



```

arbre suppression(arbre, clé)

    sous_arbre = position(arbre, clé)

slides/cours_17.md→slides_2021/cours_17.md

+0 −382
Original line number Diff line number Diff line
@@ -1127,385 +1127,3 @@ 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)



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



* `v1`, `v2`, `u`, `w` même hauteur.

* 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`, `v1`,  `v2`, `w` à la même hauteur.

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



::::



:::



# Le facteur d'équilibre (balance factor)



## Définition



```

fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))

```



## Valeurs possibles?



. . .



```

fe = {-1, 0, 1} // arbre AVL

fe = {-2, 2}    // arbre déséquilibré

```



![Illustration du `fe`](figs/facteur_equilibre.png){width=40%}



# Algorithme d'insertion



* Insérer le noeud comme d'habitude.

* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier

  noeud déséquilibré).

* Rééquilibrer le noeud si nécessaire.



## Cas possibles



::: columns



:::: column



## Sous-arbre gauche (avant)



```

fe(P) =  1 

fe(P) =  0 

fe(P) = -1 

```



::::



:::: column



## Sous-arbre gauche (après)



. . .



```

=> fe(P) =  0 

=> fe(P) = -1 

=> fe(P) = -2 // Rééquilibrer P

```



::::



:::



# Algorithme d'insertion



* Insérer le noeud comme d'habitude.

* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier

  noeud déséquilibré).

* Rééquilibrer le noeud si nécessaire.



## Cas possibles



::: columns



:::: column



## Sous-arbre droit (avant)



```

fe(P) =  1 

fe(P) =  0 

fe(P) = -1 

```



::::



:::: column



## Sous-arbre droit (après)



. . .



```

=> fe(P) =  0 

=> fe(P) = +1 

=> fe(P) = +2 // Rééquilibrer P

```



::::



:::



# Rééquilibrage



## Lien avec les cas vus plus tôt



```

fe(P) = -2 && fe(gauche(P)) = -1 => cas 1a

fe(P) = -2 && fe(gauche(P)) = +1 => cas 2a



fe(P) = +2 && fe(gauche(P)) = -1 => cas 1b

fe(P) = +2 && fe(gauche(P)) = +1 => cas 2b

```



## Dessiner les différents cas, sur le dessin ci-dessous



![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)

slides_2021/cours_18.md

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

title: "Arbres AVL"

date: "2022-03-16"

patat:

  eval:

    tai:

      command: fish

      fragment: false

      replace: true

    ccc:

      command: fish

      fragment: false

      replace: true

  images:

    backend: auto

---



# Questions sur les notions du dernier cours



* Qu'est-ce qu'un arbre AVL?



. . .



* Un arbre binaire qui a la propriété suivante:

    * La différence de hauteur de chaque noeud est d'au plus 1.

    * Tous les noeuds ont `fe = hd - hg = {-1, 0, 1}`.



* Pourquoi utiliser un arbre AVL plutôt qu'un arbre binaire de recherche?



. . .



* Insertion/recherche/... toujours en $O(\log_2(N))$.



# AVL ou pas?



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

graph TD;

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

    id0-->id2((40));

    id1-->id3((5));

    id1-->id4((10));

    id3-->id5((3));

    id3-->id6((7))

    id6-->id7((6))

    id6-->id8((  ))

    id2-->id9((33))

    id2-->id10((61))

    id9-->id11((22))

    id9-->id12((39))

    id10-->id13((  ))

    id10-->id14((81))

    style id8 fill:#fff,stroke:#fff

    style id13 fill:#fff,stroke:#fff

```



. . .



* Ajouter un noeud pour qu'il le soit plus.



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



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



* `v1`, `v2`, `u`, `w` même hauteur.

* 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`, `v1`,  `v2`, `w` à la même hauteur.

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



::::



:::



# Le facteur d'équilibre (balance factor)



## Définition



```

fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))

```



## Valeurs possibles?



. . .



```

fe = {-1, 0, 1} // arbre AVL

fe = {-2, 2}    // arbre déséquilibré

```



![Illustration du `fe`](figs/facteur_equilibre.png){width=40%}



# Algorithme d'insertion



* Insérer le noeud comme d'habitude.

* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier

  noeud déséquilibré).

* Rééquilibrer le noeud si nécessaire.



## Cas possibles



::: columns



:::: column



## Sous-arbre gauche (avant)



```

fe(P) =  1 

fe(P) =  0 

fe(P) = -1 

```



::::



:::: column



## Sous-arbre gauche (après)



. . .



```

=> fe(P) =  0 

=> fe(P) = -1 

=> fe(P) = -2 // Rééquilibrer P

```



::::



:::



# Algorithme d'insertion



* Insérer le noeud comme d'habitude.

* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier

  noeud déséquilibré).

* Rééquilibrer le noeud si nécessaire.



## Cas possibles



::: columns



:::: column



## Sous-arbre droit (avant)



```

fe(P) =  1 

fe(P) =  0 

fe(P) = -1 

```



::::



:::: column



## Sous-arbre droit (après)



. . .



```

=> fe(P) =  0 

=> fe(P) = +1 

=> fe(P) = +2 // Rééquilibrer P

```



::::



:::



# Rééquilibrage



## Lien avec les cas vus plus tôt



```

fe(P) = -2 && fe(gauche(P)) = -1 => cas 1a

fe(P) = -2 && fe(gauche(P)) = +1 => cas 2a



fe(P) = +2 && fe(droite(P)) = -1 => cas 2b

fe(P) = +2 && fe(droite(P)) = +1 => cas 1b

```



## Dessiner les différents cas, sur le dessin ci-dessous



![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)



# La rotation



## La rotation gauche (5min, matrix)



![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)



. . .



\footnotesize

```

arbre rotation_gauche(arbre P) 

    si est_non_vide(P)

        Q = droite(P)

        droite(P) = gauche(Q)

        gauche(Q) = P

        retourne Q

    retourne P

```



# La rotation en C (1/2)



## La rotation gauche



```

arbre rotation_gauche(arbre P) 

    si est_non_vide(P)

        Q = droite(P)

        droite(P) = gauche(Q)

        gauche(Q) = P

        retourne Q

    retourne P

```



## Écrire le code C correspondant (5min, matrix)



1. Structure de données

2. Fonction `tree_t rotation_left(tree_t tree)`



. . .



\footnotesize

```C

typedef struct _node {

    int key;

    struct _node *left, *right;

    int bf; // balance factor

} node;

typedef node *tree_t;

```



# La rotation en C (2/2)



\footnotesize



```C

tree_t rotation_left(tree_t tree) {

    tree_t subtree = NULL;

    if (NULL != tree) {

        subtree = tree->right;

        tree->right = subtree->left;

        subtree->left = tree;

    }

    return subtree;

}

```



. . .



* Et la rotation à droite (5min)?



. . .



```C

tree_t rotation_right(tree_t tree) {

    tree_t subtree = NULL;

    if (NULL != tree) {

        subtree = tree->left;

        tree->left = subtree->right;

        subtree->right = tree;

    }

    return subtree;

}

```



# Exemple de rotation (1/2)



## Insertion de 9?



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

graph TD;

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

    id0-->id2((6));

    id2-->id3((  ));

    id2-->id4((8));

    style id3 fill:#fff,stroke:#fff

```



# Exemple de rotation (2/2)



::: columns



:::: column



## Quelle rotation et sur quel noeud (5 ou 6)?



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

graph TD;

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

    id0-->id2((6));

    id2-->id3((  ));

    id2-->id4((8));

    id4-->id5((  ));

    id4-->id6((9));

    style id3 fill:#fff,stroke:#fff

    style id5 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Sur le plus jeune évidemment!



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

graph TD;

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

    id0-->id2((8));

    id2-->id3((6));

    id2-->id4((9));

```



::::



:::



* Cas `1a/b` *check*!





# La rotation gauche-droite



## Là c'est plus difficile (cas 2a/b)



![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)



# Exercices



## Faire l'implémentation de la double rotation (pas corrigé, 5min)



# Exercices



::: columns



:::: column



## Insérer 50, ex 10min (matrix)



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

graph TD;

    id0((89))-->id1((71));

    id0-->id2((90));

    id1-->id3((44));

    id3-->id4((37));

    id3-->id5((61));

    id1-->id6((81))

    id2-->id7((  ))

    id2-->id8((100))

    style id7 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Où se fait la rotation?



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

graph TD;

    id0((89))-->id1((71));

    id0-->id2((90));

    id1-->id3((44));

    id3-->id4((37));

    id3-->id5((61));

    id1-->id6((81))

    id2-->id7((  ))

    id2-->id8((100))

    id5-->id9((50))

    id5-->id10((  ))

    style id7 fill:#fff,stroke:#fff

    style id10 fill:#fff,stroke:#fff

```



::::



:::



# Exercices



::: columns



:::: column



## Rotation gauche en 44



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

graph TD;

    id0((89))-->id1((71));

    id0-->id2((90));

    id1-->id3((61));

    id1-->id10((81));

    id3-->id4((44));

    id3-->id5((  ));

    id4-->id6((37))

    id4-->id7((50))

    id2-->id8((  ))

    id2-->id9((100))

    style id5 fill:#fff,stroke:#fff

    style id8 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Rotation à droite en 71



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

graph TD;

    id0((89))-->id1((61));

    id0-->id2((90));

    id1-->id3((44));

    id1-->id10((71));

    id3-->id4((37));

    id3-->id5((50));

    id2-->id8((  ));

    id2-->id9((100));

    id10-->id11((  ))

    id10-->id12((81))

    style id8 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::



# Exercice de la mort



Soit l’arbre AVL suivant:



::: columns



:::: column



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

graph TD;

    id0((60))-->id1((40));

    id0-->id2((120));

    id1-->id3((20));

    id1-->id4((50));

    id3-->id5((10));

    id3-->id6((30));

    id2-->id7((100));

    id2-->id8((140));

    id7-->id9((80))

    id7-->id10((110))

    id9-->id11((70))

    id9-->id12((90))

    id8-->id13((130))

    id8-->id14((160))

    id14-->id15((150))

    id14-->id16((170))

```



::::



:::: column



1. Montrer les positions des insertions de feuille qui conduiront à un arbre

   désequilibré.

2. Donner les facteurs d’equilibre.

3. Dessiner et expliquer les modifications de l’arbre lors de l’insertion de la

   valeur `65`. On mentionnera les modifications des facteurs

   d’équilibre.



::::



:::

slides_2021/cours_19.md

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

title: "Arbres AVL et quadtrees"

date: "2022-03-23"

patat:

  eval:

    tai:

      command: fish

      fragment: false

      replace: true

    ccc:

      command: fish

      fragment: false

      replace: true

  images:

    backend: auto

---



# Questions sur les notions du dernier cours



## Quel est l'algorithme d'insertion dans un arbre AVL?



. . .



* Insertion comme dans un arbre binaire de recherche.

* Rééquilibrage si le facteur d'équilibre est de -2 ou +2.



## Quelles sont les briques élémentaires du rééquilibrage?



. . .



* La rotation gauche ou droite.



# Encore un petit exercice



* Insérer les nœuds suivants dans un arbre AVL



```

25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 | 50 | 55 | 30 | 15

```



## Un à un et le/la premier/ère qui poste la bonne réponse sur matrix a un point



# Suppression dans un arbre AVL





::: columns



:::: column



## Algorithme par problème: supprimer 10



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

graph TD;

    id0((8))-->id1((4));

    id0-->id2((10));

    id1-->id3((2));

    id1-->id4((6));

    id3-->id5((1));

    id3-->id6((  ))

    id4-->id7((  ))

    id4-->id8((7))

    id2-->id9((9))

    id2-->id10((14))

    id10-->id11((12))

    id10-->id12((16))

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Algorithme par problème: supprimer 10



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

graph TD;

    id0((8))-->id1((4));

    id0-->id2((12));

    id1-->id3((2));

    id1-->id4((6));

    id3-->id5((1));

    id3-->id6((  ))

    id4-->id7((  ))

    id4-->id8((7))

    id2-->id9((9))

    id2-->id10((14))

    id10-->id11((  ))

    id10-->id12((16))

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::



# Suppression dans un arbre AVL





::: columns



:::: column



## Algorithme par problème: supprimer 8



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

graph TD;

    id0((8))-->id1((4));

    id0-->id2((12));

    id1-->id3((2));

    id1-->id4((6));

    id3-->id5((1));

    id3-->id6((  ))

    id4-->id7((  ))

    id4-->id8((7))

    id2-->id9((9))

    id2-->id10((14))

    id10-->id11((  ))

    id10-->id12((16))

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Algorithme par problème: rotation de 12



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

graph TD;

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

    id0-->id2((12));

    id1-->id3((2));

    id1-->id4((6));

    id3-->id5((1));

    id3-->id6((  ))

    id4-->id7((  ))

    id4-->id8((7))

    id2-->id9((  ))

    id2-->id10((14))

    id10-->id11((  ))

    id10-->id12((16))

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

    style id9 fill:#fff,stroke:#fff

    style id11 fill:#fff,stroke:#fff

```



::::



:::



# Suppression dans un arbre AVL



::: columns



:::: column



## Algorithme par problème: rotation de 12



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

graph TD;

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

    id0-->id2((14));

    id1-->id3((2));

    id1-->id4((6));

    id3-->id5((1));

    id3-->id6((  ))

    id4-->id7((  ))

    id4-->id8((7))

    id2-->id9((12))

    id2-->id10((16))

    style id6 fill:#fff,stroke:#fff

    style id7 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



1. On supprime comme d'habitude.

2. On rééquilibre si besoin à l'endroit de la suppression.



* Facile non?



. . .



* Plus dur....



::::



:::



# Suppression dans un arbre AVL 2.0



::: columns



:::: column



## Algorithme par problème: suppression de 30



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

graph TD;

    id0((50))-->id1((30));

    id0-->id2((100));

    id1-->id3((10));

    id1-->id4((40));

    id3-->id5((  ));

    id3-->id6((20))

    id2-->id7((80))

    id2-->id8((200))

    id7-->id9((70))

    id7-->id10((90))

    id9-->id11((60))

    id9-->id12((  ))

    id8-->id13((  ))

    id8-->id14((300))

    style id5 fill:#fff,stroke:#fff

    style id12 fill:#fff,stroke:#fff

    style id13 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Algorithme par problème: rotation GD autour de 40



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

graph TD;

    id0((50))-->id1((40));

    id0-->id2((100));

    id1-->id3((10));

    id1-->id4((  ));

    id3-->id5((  ));

    id3-->id6((20))

    id2-->id7((80))

    id2-->id8((200))

    id7-->id9((70))

    id7-->id10((90))

    id9-->id11((60))

    id9-->id12((  ))

    id8-->id13((  ))

    id8-->id14((300))

    style id4 fill:#fff,stroke:#fff

    style id5 fill:#fff,stroke:#fff

    style id12 fill:#fff,stroke:#fff

    style id13 fill:#fff,stroke:#fff

```



::::



:::



# Suppression dans un arbre AVL 2.0



::: columns



:::: column



## Argl! 50 est déséquilibré!



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

graph TD;

    id0((50))-->id1((20));

    id0-->id2((100));

    id1-->id3((10));

    id1-->id4((40));

    id2-->id7((80))

    id2-->id8((200))

    id7-->id9((70))

    id7-->id10((90))

    id9-->id11((60))

    id9-->id12((  ))

    id8-->id13((  ))

    id8-->id14((300))

    style id12 fill:#fff,stroke:#fff

    style id13 fill:#fff,stroke:#fff

```



::::



:::: column



. . .



## Algorithme par problème: rotation DG autour de 50



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

graph TD;

    id0((80))-->id1((50));

    id0-->id2((100));

    id1-->id3((20));

    id1-->id4((70));

    id3-->id5((10));

    id3-->id6((40));

    id4-->id9((60))

    id4-->id10((  ))

    id2-->id7((90))

    id2-->id8((200))

    id8-->id13((  ))

    id8-->id14((300))

    style id10 fill:#fff,stroke:#fff

    style id13 fill:#fff,stroke:#fff

```



::::



:::



# Résumé de la suppression



1. On supprime comme pour un arbre binaire de recherche.

2. Si un nœud est déséquilibré, on le rééquilibre.

    * Cette opération pour déséquilibrer un autre nœud.

3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.



# Les arbres quaternaires



## Définition



Arbre dont chaque nœud a 4 enfants ou aucun. 



![Un exemple de quadtree.](figs/quad_ex.svg)



# Les arbres quaternaires



## Cas d'utilisation



Typiquement utilisés pour représenter des données bidimensionnelles.



Son équivalent tri-dimensionnel est l'octree (chaque nœud a 8 enfants ou aucun).



## Cas d'utilisation: images



* Stockage: compression.

* Transformations: symétries, rotations, etc.



## Cas d'utilisation: simulation



* Indexation spatiale.

* Détection de collisions.

* Simulation de galaxies, Barnes-Hut.



# Exemple de compression



::: columns



:::: {.column width=30%}



## Comment représenter l'image



![Image noir/blanc.](figs/board_blacked_parts.svg)



::::



:::: {.column width=70%}



## Sous la forme d'un arbre quaternaire?



. . .



![L'arbre quaternaire correspondant.](figs/quad_img.svg)



**Économie?**



. . .



Image 64 pixels, arbre 25 neouds.



::::



:::

slides_2021/cours_2.md

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

title: "Introduction aux algorithmes"

date: "2021-09-29"

---



# Exercice: test si un nombre est premier



## Avec tout ce que vous avez appris la dernière fois:



* Écrivez le code testant si un nombre est premier.

* Quels sont les ajouts possibles par rapport au code de la semaine passée?

* Rencontrez-vous des problèmes éventuels de compilation?

* Voyez-vous une façon de générer des nombres premiers avec votre programme?



. . .



## Implémentez-la et postez votre code sur le salon matrix (10 min).



# Corrigé: enfin pas vraiment mais juste un possible



\footnotesize 



```C

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <stdbool.h>

int main() {

   int nb = 1;

   printf("Entrez un nombre: ");

   scanf("%d", &nb);

   bool premier = true;

   for (int div = 2; div <= sqrt(nb); div++) {

      if (nb % div == 0) {

         premier = false;

         break;

      }

   }

   if (premier) {

      printf("Le nombre %d est premier\n", nb);

   } else {

      printf("Le nombre %d n'est pas premier\n", nb);

   }

   return 0;

}

```



# Quelques algorithmes simples



## Voyons quelques algorithmes supplémentaires



- Plus petit commun multiple (PPCM) de deux nombres

- Autre algorithme de calcul du PPCM de deux nombres

- Plus grand commun diviseur (PGCD) de deux nombres



# Le calcul du PPCM (1/5)



## Définition



Le plus petit commun multiple (PPCM), `p`, de deux entiers non nuls, `a` et `b`,

est le plus petit entier strictement positif qui soit multiple de ces deux

nombres.



Exemples:



```C

PPCM(3, 4) = 12,

PPCM(4, 6) = 12,

PPCM(5, 15) = 15.

```



. . .



## Mathématiquement



Décomposition en nombres premiers:



$$

36 = 2^2\cdot 3^2,\quad 90=2\cdot 5\cdot 3^2,

$$

On garde tous les premiers à la puissance la plus élevée

$$

PPCM(36, 90)=2^2\cdot 3^2\cdot 5=180.

$$



# Le calcul du PPCM (2/5)



## Exemple d'algorithme



```C

PPCM(36, 90):

36  < 90  // 36  + 36

72  < 90  // 72  + 36

108 > 90  // 90  + 90

108 < 180 // 108 + 36

144 < 180 // 144 + 36

180 = 180 // The End!

```



* 5 additions, 5 assignations, et 6 comparaisons.



. . .



## Transcrivez cet exemple en algorithme (groupe de 3), 5min



. . .



## et codez-le!





# Le calcul du PPCM (3/5)



## Tentative de correction



```C

int main() { 

    int m = 15, n = 12;

    int mult_m = m, mult_n = n;

    while (mult_m != mult_n) {

        if (mult_m > mult_n) {

            mult_n += n;

        } else {

            mult_m += m;

        }

    }

    printf("Le ppcm de %d et %d est %d\n", n, m, mult_m);

}

```



. . .



* Combien d'additions / comparaisons au pire?



# Le calcul du PPCM (4/5)



## Réusinage: Comment décrire une fonction qui ferait ce calcul (arguments, sorties)?



. . .



En `C` on pourrait la décrire comme



```C

int ppcm(int a, int b); // La **signature** de cette fonction

```



. . .



## Algorithme



Par groupe de 3 (5-10min):



* réfléchissez à un algorithme alternatif donnant le PPCM de deux nombres;

* écrivez l'algorithme en pseudo-code.



# Le calcul du PPCM (5/5)



## Indication



Si un nombre, `p`, est multiple de `a` et de `b` alors il peut s'écrire `p = a

* i = b * j`  ou encore `p / a = i` et `p / b = j`.



<!-- Si un nombre, $p$, est multiple de $a$ et de $b$ alors il peut s'écrire -->

<!-- $$ -->

<!-- p = a \cdot i = b \cdot j, -->

<!-- $$ -->

<!-- ou encore $p / a = i$ et $p / b = j$. -->



. . .



## Pseudo-code



```C

int ppcm(int a, int b) {

    for (i in [1, b]) {

        if a * i is divisible by b {

            return a * i

        }

    }

}

```



# Le code du PPCM de 2 nombres (1/2)



## Implémentez le pseudo-code et postez le code sur matrix (5min).



. . .



## Un corrigé possible





```C

#include <stdio.h>

#include <stdlib.h> 



int main() { 

   int n = 15, m = 12;

   int i = 1;

   while (n * i % m != 0) {

      i++;

   }

   printf("Le ppcm de %d et %d est %d\n", n, m, n*i);

}

```



# Le code du PPCM de 2 nombres (2/2)



## Corrigé alternatif



```C

#include <stdio.h>

#include <stdlib.h> 



int main() { 

   int res = n*m;

   for (int i = 2; i <= m; i++) {

     if (n * i % m == 0) {

        res = n * i;

        break;

     }

   }

   printf("Le ppcm de %d et %d est %d\n", n, m, res);

}

```



# Le calcul du PGCD (1/5)



## Définition



Le plus grand commun diviseur (PGCD) de deux nombres entiers non nuls est le

plus grand entier qui les divise en même temps. 



## Exemples:



```C

PGCD(3, 4) = 1,

PGCD(4, 6) = 2,

PGCD(5, 15) = 5.

```



. . .



## Mathématiquement



Décomposition en nombres premiers:



$$

36 = 2^2\cdot 3^2,\quad 90=2\cdot 5\cdot 3^2,

$$

On garde tous les premiers à la puissance la plus basse

$$

PGCD(36, 90)=2^{\min{1,2}}\cdot 3^{\min{2,2}}\cdot 5^{\min{0,1}}=18.

$$



# Le calcul du PGCD (2/5)



## Algorithme



Par groupe de 3 (5-10min):



* réfléchissez à un algorithme alternatif donnant le PGCD de deux nombres;

* écrivez l'algorithme en pseudo-code.



. . .



## Exemple d'algorithme



```C

PGCD(36, 90):

90 % 36 != 0 // otherwise 36 would be PGCD

90 % 35 != 0 // otherwise 35 would be PGCD

90 % 34 != 0 // otherwise 34 would be PGCD

...

90 % 19 != 0 // otherwise 19 would be PGCD

90 % 18 == 0 // The end!

```



* 18 modulos, 18 assignations, et 18 comparaisons.



# Le calcul du PGCD (3/5)



## Transcrivez cet exemple en algorithme (groupe de 3) et codez-le (5-10min)!



. . .



## Optimisation



* Combien d'additions / comparaisons au pire?

* Un moyen de le rendre plus efficace?



. . .



## Tentative de correction



```C

void main() {

   int n = 90, m = 78;

   int gcd = 1;

   for (int div = n; div >= 2; div--) { // div = m, sqrt(n)

      if (n % div == 0 && m % div == 0) {

         gcd = div;

         break;

      }

   }

   printf("Le pgcd de %d et %d est %d\n", n, m, gcd);

}

```



# Le calcul du PGCD (4/5)



## Réusinage: l'algorithme d'Euclide



`Dividende = Diviseur * Quotient + Reste`



```C

PGCD(35, 60):

35 = 60 * 0 + 35 // 60 -> 35, 35 -> 60

60 = 35 * 1 + 25 // 35 -> 60, 25 -> 35

35 = 25 * 1 + 10 // 25 -> 35, 20 -> 25

25 = 10 * 2 +  5 // 10 -> 25, 5  -> 10

10 =  5 * 2 +  0 // PGCD = 5!

```



. . .



## Algorithme



Par groupe de 3 (5-10min):



* analysez l'exemple ci-dessus;

* transcrivez le en pseudo-code.



# Le calcul du PGCD (5/5)



## Pseudo-code



```C

int pgcd(int a, int b) {

    tmp_n = n

    tmp_m = m

    while (tmp_m does not divide tmp_n) {

        tmp   = tmp_n

        tmp_n = tmp_m

        tmp_m = tmp modulo tmp_m

    }

    return tmp_m

}

```



# Le code du PGCD de 2 nombres



## Implémentez le pseudo-code et postez le code sur matrix (5min).



. . .



## Un corrigé possible



```C

#include <stdio.h>

void main() {

   int n = 90;

   int m = 78;

   printf("n = %d et m = %d\n", n, m);

   int tmp_n = n;

   int tmp_m = m;

   while (tmp_n%tmp_m > 0) {

      int tmp = tmp_n;

      tmp_n = tmp_m;

      tmp_m = tmp % tmp_m;

   }

   printf("Le pgcd de %d et %d est %d\n", n, m, tmp_m);

}

```

slides_2021/cours_20.md

0 → 100644
+721 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_21.md

0 → 100644
+830 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_22.md

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

title: "B-Arbres"

date: "2022-04-13"

patat:

  eval:

    tai:

      command: fish

      fragment: false

      replace: true

    ccc:

      command: fish

      fragment: false

      replace: true

  images:

    backend: auto

---



# Les B-arbres



## Problématique



* Grands jeux de données (en 1970).

* Stockage dans un arbre, mais l'arbre tiens pas en mémoire.

* Regrouper les sous-arbres en **pages** qui tiennent en mémoire.



## Exemple



* 100 noeuds par page et l'arbre comporte $10^6$ noeuds:

    * Recherche B-arbre: $\log_{100}(10^6)=3$;

    * Recherche ABR: $\log_2(10^6)=20$.

* Si on doit lire depuis le disque: $10\mathrm{ms}$ par recherche+lecture:

    * $30\mathrm{ms}$ (lecture beaucoup plus rapide que recherche) vs $200\mathrm{ms}=0.2\mathrm{s}$.



## Remarques



* On sait pas ce que veut dire `B`: Bayer, Boeing, Balanced?

* Variante plus récente B+-arbres.



# Les B-arbres



## Illustration, arbre divisé en pages de 3 noeuds



![Arbre divisé en pages de 3 noeuds](figs/barbres_page3.png)



. . .



## Utilisation



* Bases de données (souvent très grandes donc sur le disque);

* Système de fichier.



# Les B-arbres



## Avantages



* Arbres moins profonds;

* Diminue les opération de rééquilibrage;

* Complexité toujours en $\log(N)$;



. . .



## Définition: B-arbre d'ordre $n$



* Chaque page d'un arbre contient au plus $2\cdot n$ *clés*;

* Chaque page (excepté la racine) contient au moins $n$ clés;

* Chaque page qui contient $m$ clés contient soit:

    * $0$ descendants;

    * $m+1$ descendants.

* Toutes les pages terminales apparaissent au même niveau.



# Les B-arbres



## Est-ce un B-arbre?



![B-arbre d'ordre 2.](figs/barbres_exemple.png)



. . .



## Oui!



* Dans chaque noeud les clés sont **triées**.

* Chaque page contient au plus $n$ noeuds: check;

* Chaque noeud avec $m$ clés a $m+1$ descendants;

* Toutes les feuilles apparaissent au même niveau.



# Les B-arbres



## Exemple de recherche: trouver `32`



![B-arbre d'ordre 2.](figs/barbres_exemple.png)

 

. . .



* Si `n` plus petit que la 1e clé ou plus grand que la dernière descendre.

* Sinon parcourir (par bissection ou séquentiellement) jusqu'à trouver ou descendre entre 2 éléments.



# Les B-arbres



## La recherche de la clé `C` algorithme 



0. En partant de la racine.

1. Si on est dans une feuille:

    * Si la `C` est dans une page, retourner la page;

    * Sinon c'est perdu.

2. Sinon:

    * Tant que `C > page` passer à la page suivante

    * Descendre



# Les B-arbres



## Disclaimer



* Inspiration de <https://en.wikipedia.org/wiki/B-tree>



## Exemples d'insertion: `1`



![B-arbre d'ordre 1.](figs/barbres_1.svg)

 

. . .



* L'arbre est vide, on insère juste dans la première page.



# Les B-arbres



## Exemples d'insertion: `2`



![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_2.svg)

 

. . .



* La première page est pas pleine, on insère dans l'ordre (après 1).



# Les B-arbres



## Exemples d'insertion: `3`



![B-arbre d'ordre 1.](figs/barbres_2.svg){width=50%}



* Comment on insère (1min de réflexion avant de donner une réponse!)?



# Les B-arbres



## Exemples d'insertion: `3`



![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_3.svg){width=50%}

 

. . .



* La page est pleine, on crée deux enfants.

* On choisit, `2`, la médiane de `1, 2, 3` et il est inséré à la racine.

* `1` descend à gauche, `3` descend à droite.



# Les B-arbres



## Exemples d'insertion: `4`



![B-arbre d'ordre 1.](figs/barbres_3.svg){width=50%}

 

* Comment on insère (1min de réflexion avant de donner une réponse!)?



# Les B-arbres



## Exemples d'insertion: `4`



![B-arbre d'ordre 1. Nombre enfants 0 ou 2.](figs/barbres_4.svg){width=50%}

 

. . .



* On pourrait insérer à droite de `2`, mais... ça ferait 2 parents pour 2 enfants (mais `m` parents => `m+1` enfants ou `0`);

* On descend à droite (`4 > 2`);

* On insère à droite de `3`.



# Les B-arbres



## Exemples d'insertion: `5`



![B-arbre d'ordre 1.](figs/barbres_4.svg){width=50%}

 

* Comment on insère (1min de réflexion avant de donner une réponse!)?



# Les B-arbres



## Exemples d'insertion: `5`



![B-arbre d'ordre 2.](figs/barbres_5.svg)

 

. . .



* On descend à droite (on peut pas insérer à la racine comme pour `4`);

* On dépasse la capacité de l'enfant droite;

* `4`, médiane de `3, 4, 5`, remonte à la racine;

* On crée un nouveau noeud à droite de `4`;

* La règle `m => m+1` est ok.



# Les B-arbres



## Exemples d'insertion: `6`



![B-arbre d'ordre 1.](figs/barbres_5.svg){width=50%}

 

* Comment on insère (1min de réflexion avant de donner une réponse!)?



# Les B-arbres



## Exemples d'insertion: `6`



![B-arbre d'ordre 2.](figs/barbres_6.svg)

 

. . .



* `6 > 4` on descend à droite;

* `6 > 5` et on a à la place à droite, on insère.



# Les B-arbres



## Exemples d'insertion: `7`



![B-arbre d'ordre 1.](figs/barbres_6.svg){width=50%}

 

* Comment on insère (1min de réflexion avant de donner une réponse!)?



# Les B-arbres



## Exemples d'insertion: `7`



![B-arbre d'ordre 2.](figs/barbres_7.svg){width=50%}

 

. . .



* `7 > 4` on descend à droite;

* `7 > 6` mais on a dépassé la capacité;

* `6` est la médiane de `5, 6, 7`, remonte à la racine;

* `5` reste à gauche, `7` à droite, mais `6` fait dépasser la capacité de la racine;

* `4` est la médiane de `2, 4, 6`, `4` remonte, `2` reste à gauche, `6` à droite.



# Les B-arbres



## L'algorithme d'insertion



0. Rechercher la feuille (la page a aucun enfant) où insérer;

1. Si la page n'est pas pleine insérer dans l'ordre croissant.

2. Si la page est pleine, on sépare la page en son milieu :

    1. On trouve la médiane, `M`, de la page;

    2. On met les éléments `< M` dans la page de gauche de `M` et les `> M` dans la page de droite de `M`;

    3. `M` est insérée récursivement dans la page parent.



# Les B-arbres



## Exercice: insérer `22, 45, 50` dans l'arbre d'ordre 2 (3min matrix)



![](figs/barbres_ex1.png)



. . .



![](figs/barbres_ex2.png)





# Les B-arbres



## Exercice: insérer `5` dans l'arbre d'ordre 2 (3min matrix)



![](figs/barbres_ex2.png)



. . .



![](figs/barbres_ex3.png)



# Les B-arbres



## Exercice: insérer `32, 55, 60` dans l'arbre d'ordre 2 (3min matrix)



![](figs/barbres_ex3.png)



. . .



![](figs/barbres_ex4.png)



# Les B-arbres



## Exercice: insérer `41` dans l'arbre d'ordre 2 (3min matrix)



![](figs/barbres_ex4.png)



. . .



![](figs/barbres_ex5.png)



# Les B-arbres



## Exercice (matrix, 15min)



* Insérer 20, 40, 10, 30, 15, 35, 7, 26, 18, 22, 5, 42, 13, 46, 27, 8, 32, 38, 24, 45, 25, 2, 14, 28, 32, 41,

* Dans un B-arbre d'ordre 2.



# Les B-arbres



## Structure de données



* Chaque page a une contrainte de remplissage, par rapport à l'ordre de l'arbre;

* Un noeud (page) est composé d'un tableau de clés/pointeurs vers les enfants;



```

P_0 | K_1 | P_1 | K_2 |  | P_i | K_{i+1} |  | P_{m-1} | K_m | P_m

```



* `P_0`, ..., `P_m` pointeurs vers enfants;

* `K_1`, ..., `K_m` les clés.

* Il y a `m+1` pointeurs mais `m` clés.

* Comment faire pour gérer l'insertion?



# Les B-arbres



## Faire un dessin de la structure de données (3min matrix)?



. . .



![Strcture d'une page de B-arbre d'ordre 2.](figs/barbres_struct.png)



1. On veut un tableau de `P_i, K_i => struct`;

2. `K_0` va être en "trop";

3. Pour simplifier l'insertion dans une page, on ajoute un élément de plus.



# Les B-arbres



## L'insertion cas noeud pas plein, insertion `4`?



![](figs/barbres_insert_easy.svg){width=50%}



. . .



## Solution



![](figs/barbres_insert_easy_after.svg){width=50%}



# Les B-arbres



## L'insertion cas noeud pas plein, insertion `N`



* On décale les éléments plus grand que `N`;

* On insère `N` dans la place "vide";

* Si la page n'est pas pleine, on a terminé.



# Les B-arbres



## L'insertion cas noeud plein, insertion `2`?



![](figs/barbres_insert_hard_before.svg){width=50%}



. . .



## Solution



![](figs/barbres_insert_hard_during.svg){width=50%}



# Les B-arbres



## L'insertion cas noeud plein, promotion `3`?



![](figs/barbres_insert_hard_during.svg){width=50%}



. . .



## Solution



![](figs/barbres_insert_hard_after.svg)



# Les B-arbres



## L'insertion cas noeud plein, insertion `N`



* On décale les éléments plus grand que `N`;

* On insère `N` dans la place "vide";

* Si la page est pleine:

    * On trouve la valent médiance `M` de la page (quel indice?);

    * On crée une nouvelle page de droite;

    * On copie les valeur à droite de `M` dans la nouvelle page;

    * On promeut `M` dans la page du dessus;

    * On connecte le pointeur de gauche de `M` et de droite de `M` avec l'ancienne et la nouvelle page respectivement.



# Les B-arbres



## Pseudo-code structure de données (3min, matrix)?



. . .



```C

struct page

    entier ordre, nb

    element tab[2*ordre + 2]

```



```C

struct element

    int clé

    page pg

```



# Les B-arbres



\footnotesize



## Les fonctions utilitaires (5min matrix)



```C

booléen est_feuille(page)     // la page est elle une feuille?

entier position(page, valeur) // à quelle indice on insère?

booléen est_dans_page(page, valeur) // la valeur est dans la page

```



. . .



```C

booléen est_feuille(page) 

    retourne (page.tab[0].pg == vide)



entier position(page, valeur)

    i = 0

    tant que i < page.nb && val >= page.tab[i+1].clef

        i += 1

    retourne i



booléen est_dans_page(page, valeur)

    i = position(page, valeur)

    retourne (page.nb > 0 && page.tab[i].val == valeur)

```



# Les B-arbres



\footnotesize



## Les fonctions utilitaires (5min matrix)



```C

page nouvelle_page(ordre)  // creer une page

rien liberer_memoire(page) // liberer tout un arbre!

```

. . .



```C

page nouvelle_page(ordre)

    page = allouer(page)

    page.ordre = ordre

    page.nb = 0

    page.tab = allouer(2*ordre+2)

    retourner page



rien liberer_memoire(page)

    si est_feuille(page)

        liberer(page.tab)

        liberer(page)

    sinon

        pour fille dans page.tab

            liberer_memoire(fille)

        liberer(page.tab)

        liberer(page)

```



# Les B-arbres



## Les fonctions (5min matrix)



```C

page recherche(page, valeur) // retourner la page contenant

                             // la valeur ou vide 

```



. . .



```C

page recherche(page, valeur)

    si est_dans_page(page, valeur)

        retourne page

    sinon si est_feuille(page) 

        retourne vide

    sinon

        recherche(page.tab[position(page, valeur)], valeur)

```



# Les B-arbres



## Les fonctions



```C

page inserer_valeur(page, valeur) // inserer une valeur

```



. . .



```C

page inserer_valeur(page, valeur)

    element = nouvel_element(valeur)

    // on change element pour savoir s'il faut le remonter

    inserer_element(page, element) 

    si element.page != vide && page.nb > 2*page.ordre

        // si on atteint le sommet!

        page = ajouter_niveau(page, element) 

    retourne page

```



# Les B-arbres



## Les fonctions



```C

rien inserer_element(page, element) // inserer un element et voir s'il remonte

```



. . .



```C

rien inserer_element(page, element)

    si est_feuille(page)

        placer(page, element)

    sinon

        sous_page = page.tab[position(page, element)].page

        inserer_element(sous_page, element)

        // un element a été promu

        si element.page != vide

            placer(page, element)

```



# Les B-arbres



## Les fonctions (5min matrix)



```C

rien placer(page, element) // inserer un élément

```



. . .



```C

rien placer(page, element)

    pos = position(page, element.clé)

    pour i de 2*page.ordre à pos+1

        page.tab[i+1] = page.tab[i]

    page.tab[pos+1] = element

    page.nb += 1

    si page.nb > 2*page.ordre

        scinder(page, element)

```



# Les B-arbres



## Les fonctions (5min matrix)



```C

rien scinder(page, element) // casser une page et remonter

```



. . .



```C

rien scinder(page, element)

    new_page = new_page(page.ordre)

    new_page.nb = page.ordre

    pour i de 0 à ordre inclu

        new_page.tab[i] = page.tab[i+ordre+1]

    element.clé = page.tab[ordre+1].clé

    element.page = new_page

```



# Les B-arbres



## Les fonctions (5min matrix)



```C

page ajouter_niveau(page, element) // si on remonte à la racine...

                                   // on doit créer une nouvelle racine

```



. . .



```C

page ajouter_niveau(page, element) 

    tmp = nouvelle_page(page.ordre)

    tmp.tab[0].page = page

    tmp.tab[1].clé = element.clé

    tmp.tab[1].page = element.page

    retourne tmp

```





<!-- # Les B-arbres -->



<!-- ## Structure de données en C (3min, matrix) -->



<!-- . . . -->



<!-- ```C -->

<!-- typedef struct _page { -->

<!--     int order, nb; -->

<!--     struct _element *tab; -->

<!-- } page; -->

<!-- ``` -->



<!-- ```C -->

<!-- typedef struct element { -->

<!--     int key; -->

<!--     struct _page *pg; -->

<!-- } element; -->

<!-- ``` -->

slides_2021/cours_23.md

0 → 100644
+445 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_24.md

0 → 100644
+883 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_25.md

0 → 100644
+579 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_26.md

0 → 100644
+776 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/cours_27.md

0 → 100644
+681 −0

File added.

Preview size limit exceeded, changes collapsed.

slides_2021/docker-compose.yml

0 → 100644
+14 −0
Original line number Diff line number Diff line 
version: "3.3"

services:

    slides:

        #To use dockerfile : build: . 

        image:  omalaspinas/pandoc:latest

        environment:

            USER: 1000

            GROUP: 1000

        container_name: slides

        volumes:

            - ./:/data

        # entrypoint: ["make", "all"]

        working_dir: /data

        # user: "$(id -u):$(id -g)"