ea595f28bf2c6010534feb0e562c869b47620c95 to main · algorithmique / cours

Some changes are not shown.

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

README.md

+12 −6

Original line number	Original line	Diff line number	Diff line
	# Remerciements et contributions		# Remerciements et contributions

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

	* P. Kunzli
	* A. Boyer
	* G. Legouic
	* P. Albuquerque		* P. Albuquerque
	* O. Malaspinas		* J. Bach
			* A. Boyer
			* M. Corboz
			* M. Divià
			* Y. El Hakouni
	* A. Escribano		* A. Escribano
			* P. Kunzli
			* G. Legouic
			* G. Marino Jarrin
			* H. Radhwan
			* I. Saroukhanian
			* C. Volta

slides/.gitignore

+1 −4

Original line number	Original line	Diff line number	Diff line
	*.pdf		*.pdf
			*.json
	*.err		*.err
	*.markdown
	*.html
	index.md
	.puppeteer.json

slides/Makefile

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -18,14 +18,15 @@ all: puppeteer $(PDF)
	# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf		# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf

	docker: docker-compose.yml		docker: docker-compose.yml
	docker-compose run slides		docker compose run slides

	docker_clean: docker-compose.yml		docker_clean: docker-compose.yml
	docker-compose run slides clean		docker compose run slides clean

	puppeteer:		puppeteer:
	@echo "Setting chromium to $(CHROMIUM) for puppeteer"		@echo "Setting chromium to $(CHROMIUM) for puppeteer"
	@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json		@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		index.md: gen_index.sh
	$(shell ./gen_index.sh)		$(shell ./gen_index.sh)

slides/cours_1.md

+10 −219

Original line number	Original line	Diff line number	Diff line
	---		---
	title: "Introduction aux algorithmes"		title: "Introduction aux algorithmes I"
	date: "2022-09-21"		date: "2025-09-16"
	---		---

	# Qu'est-ce qu'un algorithme?		# 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;		* Boucles;
	* Structures de contrôle;		* Structures de contrôle;
	* Fonctions;		* Fonctions;
	@@ -79,7 +79,7 @@ booléen est_premier(nombre)

	```C		```C
	booléen est_premier(nombre) // fonction		booléen est_premier(nombre) // fonction
	soit i = 2; // variable, type, assignation		soit i = 2 // variable, type, assignation
	tant que i < nombre // boucle		tant que i < nombre // boucle
	si nombre modulo i == 0 // expression typée		si nombre modulo i == 0 // expression typée
	retourne faux // expression typée		retourne faux // expression typée
	@@ -99,7 +99,7 @@ bool est_premier(int nombre) {
	if (0 == nombre % i) { // is i divise nombre		if (0 == nombre % i) { // is i divise nombre
	return false; // i n'est pas premier		return false; // i n'est pas premier
	}		}
	i += 1; // sinon on incrémente i		i = i + 1; // sinon on incrémente i
	}		}
	return true;		return true;
	}		}
	@@ -121,8 +121,8 @@ bool est_premier(int nombre) {

	- Il existe une multitude d'options de compilation:		- Il existe une multitude d'options de compilation:

	```bash		```console
	$ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog		$ gcc -O1 -std=c11 -Wall -Wextra -g prog.c -o prog
	-fsanitize=address		-fsanitize=address
	```		```
	1. `-std=c11` utilisation de C11.		1. `-std=c11` utilisation de C11.
	@@ -240,7 +240,7 @@ int main() {

	# Quiz: compile ou compile pas?		# 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)		# Types de base (1/4)

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

	# Quiz: booléens		# 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 -->		<!-- TODO Quiz en ligne -->
	<!-- ```C		<!-- ```C
	@@ -332,7 +332,7 @@ if (x) { /* vrai */ }

	# Quiz: conversions		# 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 -->		<!-- TODO Quiz en ligne -->
	<!-- ```C		<!-- ```C
	@@ -347,212 +347,3 @@ bool d = 2.78; // 1
	bool e = 1.0; // 1		bool e = 1.0; // 1
	``` -->		``` -->

	# Expressions et opérateurs (1/6)

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

	## Expressions simples

	- Pas d'opérateurs impliqués.
	- Les littéraux, les variables, et les constantes.

	```C
	const int L = -1; // 'L' est une constante, -1 un littéral
	int x = 0; // '0' est un litéral
	int y = x; // 'x' est une variable
	int z = L; // 'L' est une constante
	```

	## Expressions complexes

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

	```C
	int x; // pas une expression (une instruction)
	x = 4 + 5; // 4 + 5 est une expression
	// dont le résultat est affecté à 'x'
	```

	# Expressions et opérateurs (2/6)

	## Opérateurs relationnels

	Opérateurs testant la relation entre deux expressions:

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

	\| Opérateur \| Syntaxe \| Résultat \|
	\|-----------\|--------------\|----------------------\|
	\| `<`{.C} \| `a < b`{.C} \| 1 si a < b; 0 sinon \|
	\| `>`{.C} \| `a > b`{.C} \| 1 si a > b; 0 sinon \|
	\| `<=`{.C} \| `a <= b`{.C} \| 1 si a <= b; 0 sinon \|
	\| `>=`{.C} \| `a >= b`{.C} \| 1 si a >= b; 0 sinon \|
	\| `==`{.C} \| `a == b`{.C} \| 1 si a == b; 0 sinon \|
	\| `!=`{.C} \| `a != b`{.C} \| 1 si a != b; 0 sinon \|

	# Expressions et opérateurs (3/6)

	## Opérateurs logiques

	\| Opérateur \| Syntaxe \| Signification \|
	\|-----------\|--------------\|----------------------\|
	\| `&&`{.C} \| `a && b`{.C} \| ET logique \|
	\| `\|\|`{.C} \| `a \|\| b`{.C} \| OU logique \|
	\| `!`{.C} \| `!a`{.C} \| NON logique \|

	# Quiz: opérateurs logiques

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

	<!-- TODO: Quiz -->
	<!-- ```C
	1 && 0 == 0
	7 && 3 == 1
	4 \|\| 3 == 1
	!34 == 0
	!0 == 1

	Soit n un unsigned char initialisé à 127:
	!n == 0
	``` -->

	# Expressions et opérateurs (4/6)

	## Opérateurs arithmétiques

	\| Opérateur \| Syntaxe \| Signification \|
	\|-----------\|--------------\|----------------------\|
	\| `+`{.C} \| `a + b`{.C} \| Addition \|
	\| `-`{.C} \| `a - b`{.C} \| Soustraction \|
	\| ``{.C} \| `a b`{.C} \| Multiplication \|
	\| `/`{.C} \| `a / b`{.C} \| Division \|
	\| `%`{.C} \| `a % b`{.C} \| Modulo \|

	# Expressions et opérateurs (5/6)

	## Opérateurs d'assignation

	\| Opérateur \| Syntaxe \| Signification \|
	\|-----------\|--------------\|---------------------------------------------\|
	\| `=`{.C} \| `a = b`{.C} \| Affecte la valeur `b` à la variable `a` \|
	\| \| \| et retourne la valeur de `b` \|
	\| `+=`{.C} \| `a += b`{.C} \| Additionne la valeur de `b` à `a` et \|
	\| \| \| assigne le résultat à `a`. \|
	\| `-=`{.C} \| `a -= b`{.C} \| Soustrait la valeur de `b` à `a` et \|
	\| \| \| assigne le résultat à `a`. \|
	\| `=`{.C} \| `a = b`{.C} \| Multiplie la valeur de `b` à `a` et \|
	\| \| \| assigne le résultat à `a`. \|
	\| `/=`{.C} \| `a /= b`{.C} \| Divise la valeur de `b` à `a` et \|
	\| \| \| assigne le résultat à `a`. \|
	\| `%=`{.C} \| `a %= b`{.C} \| Calcule le modulo la valeur de `b` à `a` et \|
	\| \| \| assigne le résultat à `a`. \|

	# Expressions et opérateurs (6/6)

	## Opérateurs d'assignation (suite)

	\| Opérateur \| Syntaxe \| Signification \|
	\|-----------\|--------------\|---------------------------------------------\|
	\| `++`{.C} \| `++a`{.C} \| Incrémente la valeur de `a` de 1 et \|
	\| \| \| retourne le résultat (`a += 1`). \|
	\| `--`{.C} \| `--a`{.C} \| Décrémente la valeur de `a` de 1 et \|
	\| \| \| retourne le résultat (`a -= 1`). \|
	\| `++`{.C} \| `a++`{.C} \| Retourne `a`{.C} et incrémente `a` de 1. \|
	\| `--`{.C} \| `a--`{.C} \| Retourne `a`{.C} et décrémente `a` de 1. \|


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

	## Syntaxe

	```C
	if (expression) {
	instructions;
	} else if (expression) { // optionnel
	// il peut y en avoir plusieurs
	instructions;
	} else {
	instructions; // optionnel
	}
	```

	```C
	if (x) { // si x s'évalue à `vrai`
	printf("x s'évalue à vrai.\n");
	} else if (y == 8) { // si y vaut 8
	printf("y vaut 8.\n");
	} else {
	printf("Ni l'un ni l'autre.\n");
	}
	```

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

	## Pièges

	```C
	int x, y;
	x = y = 3;
	if (x = 2)
	printf("x = 2 est vrai.\n");
	else if (y < 8)
	printf("y < 8.\n");
	else if (y == 3)
	printf("y vaut 3 mais cela ne sera jamais affiché.\n");
	else
	printf("Ni l'un ni l'autre.\n");
	x = -1; // toujours évalué
	```

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

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


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

	## La boucle `while`{.C}

	```C
	while (condition) {
	instructions;
	}
	do {
	instructions;
	} while (condition);
	```

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

	```C
	int sum = 0; // syntaxe C99
	while (sum < 10) {
	sum += 1;
	}
	do {
	sum += 10;
	} while (sum < 100)
	```

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

	## La boucle `for`{.C}

	```C
	for (expression1; expression2; expression3) {
	instructions;
	}
	```

	## La boucle `for`{.C}

	```C
	int sum = 0; // syntaxe C99
	for (int i = 0; i < 10; i++) {
	sum += i;
	}

	for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
	printf("C'est plus ésotérique.\n");
	}
	```

slides/intro.md

+18 −19

Original line number	Original line	Diff line number	Diff line
	---		---
	title: "Introduction générale"		title: "Introduction générale"
	date: "2022-09-20"		date: "2025-09-16"
	---		---

	# La hotline		# La hotline
	@@ -11,10 +11,9 @@ Paul Albuquerque paul.albuquerque@hesge.ch B410
	Orestis Malaspinas orestis.malaspinas@hesge.ch A401		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!		- On va intensivement utiliser Element, installez le et utilisez le!
			- Espace de discussion Matrix: <https://rb.gy/ku5es>, installez [element.io](https://element.io).
	* Espace de discussion [Matrix](https://matrix.to/#/!aKYVlcclmPGYXQFxAK:matrix.org?via=matrix.org), installez [element.io](https://element.io).

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

	@@ -23,31 +22,31 @@ Orestis Malaspinas orestis.malaspinas@hesge.ch A401
	Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:		Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:

	- Algorithmes et structures de données		- Algorithmes et structures de données
	- <https://cyberlearn.hes-so.ch/course/view.php?id=13941>		- <https://cyberlearn.hes-so.ch/course/view.php?id=7276>
	- Clé d'inscription: algo_2021_22		- Clé d'inscription: algo_2025_26

	- Programmation Sequentielle en C		- Programmation séquentielle en C
	- <https://cyberlearn.hes-so.ch/course/view.php?id=12399>		- <https://cyberlearn.hes-so.ch/course/view.php?id=7282>
	- Clé d'inscription: prog_seq_2021_22		- Clé d'inscription: prog_seq_2025_26


	# Organisation du module		# Organisation du module

	* Deux cours, 50% chacun.		## Cinq cours, 20% chacun.
	1. Algorithmes et structures de données:
			1. Algorithmes et structures de données (2 semestres):
	* 1er semestre:		* 1er semestre:
	* bases de programmation en C jusqu'à Noël.		* bases de programmation en C jusqu'à Noël,
	* algorithmique jusqu'à fin janvier.		* algorithmique jusqu'à fin janvier.
	* 2e semestre:		* 2ème semestre:
	* algorithmique.		* algorithmique.
	* Deux évaluations écrites par semestre (1er: novembre et janvier).		* Deux évaluations écrites par semestre (1er sem.: novembre et janvier).
	2. Programmation séquentielle en C		2. Programmation séquentielle en C (2 semestres)
	* Familiarisation avec l'environnement Linux.		* Familiarisation avec l'environnement Linux.
	* Travaux pratiques en C.		* Travaux pratiques en C.
	* Apprentissage du gestionnaire de versions: git.		* Apprentissage du gestionnaire de versions: git.
	* Plusieurs exercices illustrant les concepts d'algorithmique.		* Plusieurs exercices illustrant les concepts d'algorithmique.
	* Évaluations:		* Évaluations (4 tests machine).
	* Deux évaluations machine (1er semestre).		3. Programmation système (semestre de printemps)
	* Probablement, une évaluation machine et un projet (2e semestre).

slides/metadata.yaml

+3 −3

Original line number	Original line	Diff line number	Diff line
	---		---
	subtitle: "Algorithmique et structures de données, 2022-2023"		subtitle: "Algorithmique et structures de données, 2025-2026"
	author: "P. Albuquerque (B410), P. Künzli et O. Malaspinas (A401), ISC, HEPIA"		author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"
	institute: En partie inspirés des supports de cours de P. Albuquerque		institute: En partie inspiré des supports de cours de P. Albuquerque
	lang: fr-CH		lang: fr-CH
	revealjs-url: /reveal.js		revealjs-url: /reveal.js
	mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"		mathjaxurl: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"

slides_2022/Makefile

0 → 100644

+61 −0

Original line number	Original line	Diff line number	Diff line
			PDFOPTIONS = -t beamer
			# PDFOPTIONS += -F pantable
			PDFOPTIONS += -F mermaid-filter
			PDFOPTIONS += --highlight-style my_highlight.theme
			PDFOPTIONS += --pdf-engine xelatex
			PDFOPTIONS += -V theme:metropolis
			PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot
			PDFOPTIONS += -V fontsize=smaller
			PDFOPTIONS += -V urlcolor=blue

			MD=$(wildcard *.md) # Tous les fichiers .md
			PDF=$(MD:%.md=%.pdf) # Pour les fichier pdf on transforme .md -> .pdf
			HTML=$(MD:%.md=%.html) # Pour les fichier html on transforme .md -> .html
			MARKDOWN=$(MD:%.md=%.markdown) # Pour les fichier markdown on transforme .md -> .markdown
			CHROMIUM:=$(shell which chromium \|\| which chromium-browser)

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

			docker: docker-compose.yml
			docker-compose run slides

			docker_clean: docker-compose.yml
			docker-compose run slides clean

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

			index.md: gen_index.sh
			$(shell ./gen_index.sh)

			index.html: index.md
			pandoc -s $(OPTIONS) --css ../css/tufte-css/tufte.css -o $@ $^

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

			%.pdf: %.md metadata.yaml # %.pdf (chaque fichier %.md génère un fichier avec le même nom mais l'extension .pdf et la dépendance metadata.yaml)
			pandoc -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^

			%.markdown: %.md metadata.yaml yq
			sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
			grep -v -F -x -f no_header $< > header.yaml
			echo "---" > tmp.yaml
			./yq_linux_amd64 merge metadata.yaml header.yaml >> tmp.yaml
			cat tmp.yaml no_header > $@
			rm no_header header.yaml tmp.yaml

			yq: # On peut même télécharger un petit programme avec notre makefile
			wget -nc https://github.com/mikefarah/yq/releases/download/3.4.1/yq_linux_amd64
			chmod "u+x" yq_linux_amd64

			deploy: all index.html
			mkdir -p algo_cours
			cp *.pdf algo_cours
			cp index.html algo_cours

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

			.PHONY: clean index.md puppeteer yq

slides_2022/cours_1.md

0 → 100644

+558 −0

Original line number	Original line	Diff line number	Diff line
			---
			title: "Introduction aux algorithmes"
			date: "2022-09-21"
			---

			# Qu'est-ce qu'un algorithme?

			## Définition informelle (recette)

			* des entrées (les ingrédients, le matériel utilisé) ;
			* des instructions élémentaires simples (frire, flamber, etc.), dont les
			exécutions dans un ordre précis amènent au résultat voulu ;
			* un résultat : le plat préparé.

			. . .

			## Histoire et étymologie

			- Existent depuis 4500 ans au moins (algorithme de division, crible
			d'Eratosthène).
			- Le mot algorithme est dérivé du nom du mathématicien perse
			Muḥammad ibn Musā al-Khwārizmī, qui a été "latinisé" comme
			Algoritmi.

			. . .

			## Définition formelle

			En partant d'un état initial et d'entrées (peut-être vides), une séquence finie
			d'instruction bien définies (ordonnées) implémentables sur un ordinateur, afin
			de résoudre typiquement une classe de problèmes ou effectuer un calcul.

			# Notions de base d'algorithmique

			## Variable

			. . .

			* Paire: identifiant - valeur (assignation);

			## Séquence d'instructions / expressions

			. . .

			* Opérateurs (arthimétiques / booléens)
			* Boucles;
			* Structures de contrôle;
			* Fonctions;


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

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

			. . .

			## Algorithme naïf (problème)

			```C
			booléen est_premier(nombre)
			si
			pour tout i, t.q. 1 < i < nombre
			i ne divise pas nombre
			alors vrai
			sinon faux
			```

			. . .

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

			. . .

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

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

			## Algorithme naïf (une solution)

			```C
			booléen est_premier(nombre) // fonction
			soit i = 2; // variable, type, assignation
			tant que i < nombre // boucle
			si nombre modulo i == 0 // expression typée
			retourne faux // expression typée
			i = i + 1
			retourne vrai // expression typée
			```

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

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

			```C
			bool est_premier(int nombre) {
			int i; // i est un entier
			i = 2; // assignation i à 2
			while (i < nombre) { // boucle avec condition
			if (0 == nombre % i) { // is i divise nombre
			return false; // i n'est pas premier
			}
			i += 1; // sinon on incrémente i
			}
			return true;
			}
			```

			. . .

			## Exercice: Comment faire plus rapide?

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

			- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
			- Pour un code `prog.c` la compilation "minimale" est

			```bash
			$ gcc prog.c
			$ ./a.out # exécutable par défaut
			```

			- Il existe une multitude d'options de compilation:

			```bash
			$ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog
			-fsanitize=address
			```
			1. `-std=c11` utilisation de C11.
			2. `-Wall et -Wextra` activation des warnings.
			3. `-fsanitize=…` contrôles d’erreurs à l’exécution (coût en performance).
			4. `-g` symboles de débogages sont gardés.
			5. `-o` défini le fichier exécutable à produire en sortie.
			6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation



			# La simplicité de C?

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

			---------------- -------------- ---------------- ---------------
			`auto`{.C} `double`{.C} `int`{.C} `struct`{.C}
			`break`{.C} `else`{.C} `long`{.C} `switch`{.C}
			`case`{.C} `enum`{.C} `register`{.C} `typedef`{.C}
			`char`{.C} `extern`{.C} `return`{.C} `union`{.C}
			`const`{.C} `float`{.C} `short`{.C} `unsigned`{.C}
			`continue`{.C} `for`{.C} `signed`{.C} `void`{.C}
			`default`{.C} `goto`{.C} `sizeof`{.C} `volatile`{.C}
			`do`{.C} `if`{.C} `static`{.C} `while`{.C}
			---------------- -------------- ---------------- ---------------

			# Déclaration et typage

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

			```C
			const double two = 2.0; // déclaration et init.
			int x; // déclaration (instruction)
			char c; // déclaration (instruction)
			x = 1; // affectation (expression)
			c = 'a'; // affectation (expression)
			int y = x; // déclaration et initialisation en même temps
			int a, b, c; // déclarations multiples
			a = b = c = 1; // init. multiples
			```

			# Les variables (1/2)

			## Variables et portée

			- Une variable est un identifiant, qui peut être liée à une valeur (un expression).
			- Une variable a une portée qui définit où elle est visible (où elle peut être accédée).
			- La portée est globale ou locale.
			- Une variable est globale est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.
			- Une variable est locale lorsqu'elle est déclarée dans un bloc, `{...}`{.C}.
			- Une variable est dans la portée après avoir été déclarée.

			# Les variables (2/2)

			## Exemple

			```C
			float max; // variable globale accessible partout
			int foo() {
			// max est visible ici
			float a = max; // valide
			// par contre les varibles du main() ne sont pas visibles
			}
			int main() {
			// max est visible ici
			int x = 1; // x est locale à main
			{
			// x est visible ici, y pas encore
			// on peut par exemple pas faire x = y;
			int y = 2;
			} // y est détruite à la sortie du bloc
			} // x est à la sortie de main

			```

			<!-- TODO: quiz, compile, compile pas -->
			<!-- ```C
			int main() {
			global = 1;
			} // COMPILE PAS
			```

			```C
			int main() {
			int global = 1;
			{
			printf("global = %d", global);
			}
			} // COMPILE
			```

			```C
			int local;

			int main() {
			local = 1;
			{
			printf("local = %d", local);
			}
			} // COMPILE
			```

			```C
			#include <stdio.h>
			int local = 0;

			int main() {
			int local = -1;
			{
			int local = 1;
			printf("local = %d\n", local);
			}
			} // COMPILE
			``` -->

			# Quiz: compile ou compile pas?

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

			# Types de base (1/4)

			## Numériques

			Type Signification (gcc pour x86-64)
			---------------------------------- ---------------------------------------------
			`char`{.C}, `unsigned char`{.C} Entier signé/non-signé 8-bit
			`short`{.C}, `unsigned short`{.C} Entier signé/non-signé 16-bit
			`int`{.C}, `unsigned int`{.C} Entier signé/non-signé 32-bit
			`long`{.C}, `unsigned long`{.C} Entier signé/non-signé 64-bit
			`float`{.C} Nombre à virgule flottante, simple précision
			`double`{.C} Nombre à virgule flottante, double précision
			---------------------------------- ---------------------------------------------

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

			# Types de base (2/4)

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

			Type Signification
			---------------------------------- ---------------------------------------------
			`int8_t`{.C}, `uint8_t`{.C} Entier signé/non-signé 8-bit
			`int16_t`{.C}, `uint16_t`{.C} Entier signé/non-signé 16-bit
			`int32_t`{.C}, `uint32_t`{.C} Entier signé/non-signé 32-bit
			`int64_t`{.C}, `uint64_t`{.C} Entier signé/non-signé 64-bit
			---------------------------------- ---------------------------------------------

			. . .

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

			# Types de base (3/4)

			## Booléens

			- Le ANSI C n'offre pas de booléens.
			- L'entier `0`{.C} signifie faux, tout le reste vrai.
			- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.
			- En réalité c'est un entier:
			- $1 \Rightarrow$ `true`{.C}
			- $0 \Rightarrow$ `false`{.C}
			- On peut les manipuler comme des entier (les sommer, les multiplier, ...).

			# Quiz: booléens

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

			<!-- TODO Quiz en ligne -->
			<!-- ```C
			if (42) { /* vrai */ }

			int x = 100;
			if (x == 4) { /* faux */ }
			if (x) { /* vrai */ }

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

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

			#include <stdbool.h>

			bool x = true;
			if (x) { /* vrai */ }
			``` -->

			# Types de base (4/4)

			## Conversions

			- Les conversions se font de manière:
			- Explicite:
			```C
			int a = (int)2.8;
			double b = (double)a;
			int c = (int)(2.8+0.5);
			```
			- Implicite:
			```C
			int a = 2.8; // warning, si activés, avec clang
			double b = a + 0.5;
			char c = b; // pas de warning...
			int d = 'c';
			```

			# Quiz: conversions

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

			<!-- TODO Quiz en ligne -->
			<!-- ```C
			int a = (int)2.8; // 2

			double b = 2.85;
			int c = b + 0.5; // 3

			int d = a + 0.5; // 2

			bool d = 2.78; // 1
			bool e = 1.0; // 1
			``` -->

			# Expressions et opérateurs (1/6)

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

			## Expressions simples

			- Pas d'opérateurs impliqués.
			- Les littéraux, les variables, et les constantes.

			```C
			const int L = -1; // 'L' est une constante, -1 un littéral
			int x = 0; // '0' est un litéral
			int y = x; // 'x' est une variable
			int z = L; // 'L' est une constante
			```

			## Expressions complexes

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

			```C
			int x; // pas une expression (une instruction)
			x = 4 + 5; // 4 + 5 est une expression
			// dont le résultat est affecté à 'x'
			```

			# Expressions et opérateurs (2/6)

			## Opérateurs relationnels

			Opérateurs testant la relation entre deux expressions:

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

			\| Opérateur \| Syntaxe \| Résultat \|
			\|-----------\|--------------\|----------------------\|
			\| `<`{.C} \| `a < b`{.C} \| 1 si a < b; 0 sinon \|
			\| `>`{.C} \| `a > b`{.C} \| 1 si a > b; 0 sinon \|
			\| `<=`{.C} \| `a <= b`{.C} \| 1 si a <= b; 0 sinon \|
			\| `>=`{.C} \| `a >= b`{.C} \| 1 si a >= b; 0 sinon \|
			\| `==`{.C} \| `a == b`{.C} \| 1 si a == b; 0 sinon \|
			\| `!=`{.C} \| `a != b`{.C} \| 1 si a != b; 0 sinon \|

			# Expressions et opérateurs (3/6)

			## Opérateurs logiques

			\| Opérateur \| Syntaxe \| Signification \|
			\|-----------\|--------------\|----------------------\|
			\| `&&`{.C} \| `a && b`{.C} \| ET logique \|
			\| `\|\|`{.C} \| `a \|\| b`{.C} \| OU logique \|
			\| `!`{.C} \| `!a`{.C} \| NON logique \|

			# Quiz: opérateurs logiques

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

			<!-- TODO: Quiz -->
			<!-- ```C
			1 && 0 == 0
			7 && 3 == 1
			4 \|\| 3 == 1
			!34 == 0
			!0 == 1

			Soit n un unsigned char initialisé à 127:
			!n == 0
			``` -->

			# Expressions et opérateurs (4/6)

			## Opérateurs arithmétiques

			\| Opérateur \| Syntaxe \| Signification \|
			\|-----------\|--------------\|----------------------\|
			\| `+`{.C} \| `a + b`{.C} \| Addition \|
			\| `-`{.C} \| `a - b`{.C} \| Soustraction \|
			\| ``{.C} \| `a b`{.C} \| Multiplication \|
			\| `/`{.C} \| `a / b`{.C} \| Division \|
			\| `%`{.C} \| `a % b`{.C} \| Modulo \|

			# Expressions et opérateurs (5/6)

			## Opérateurs d'assignation

			\| Opérateur \| Syntaxe \| Signification \|
			\|-----------\|--------------\|---------------------------------------------\|
			\| `=`{.C} \| `a = b`{.C} \| Affecte la valeur `b` à la variable `a` \|
			\| \| \| et retourne la valeur de `b` \|
			\| `+=`{.C} \| `a += b`{.C} \| Additionne la valeur de `b` à `a` et \|
			\| \| \| assigne le résultat à `a`. \|
			\| `-=`{.C} \| `a -= b`{.C} \| Soustrait la valeur de `b` à `a` et \|
			\| \| \| assigne le résultat à `a`. \|
			\| `=`{.C} \| `a = b`{.C} \| Multiplie la valeur de `b` à `a` et \|
			\| \| \| assigne le résultat à `a`. \|
			\| `/=`{.C} \| `a /= b`{.C} \| Divise la valeur de `b` à `a` et \|
			\| \| \| assigne le résultat à `a`. \|
			\| `%=`{.C} \| `a %= b`{.C} \| Calcule le modulo la valeur de `b` à `a` et \|
			\| \| \| assigne le résultat à `a`. \|

			# Expressions et opérateurs (6/6)

			## Opérateurs d'assignation (suite)

			\| Opérateur \| Syntaxe \| Signification \|
			\|-----------\|--------------\|---------------------------------------------\|
			\| `++`{.C} \| `++a`{.C} \| Incrémente la valeur de `a` de 1 et \|
			\| \| \| retourne le résultat (`a += 1`). \|
			\| `--`{.C} \| `--a`{.C} \| Décrémente la valeur de `a` de 1 et \|
			\| \| \| retourne le résultat (`a -= 1`). \|
			\| `++`{.C} \| `a++`{.C} \| Retourne `a`{.C} et incrémente `a` de 1. \|
			\| `--`{.C} \| `a--`{.C} \| Retourne `a`{.C} et décrémente `a` de 1. \|


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

			## Syntaxe

			```C
			if (expression) {
			instructions;
			} else if (expression) { // optionnel
			// il peut y en avoir plusieurs
			instructions;
			} else {
			instructions; // optionnel
			}
			```

			```C
			if (x) { // si x s'évalue à `vrai`
			printf("x s'évalue à vrai.\n");
			} else if (y == 8) { // si y vaut 8
			printf("y vaut 8.\n");
			} else {
			printf("Ni l'un ni l'autre.\n");
			}
			```

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

			## Pièges

			```C
			int x, y;
			x = y = 3;
			if (x = 2)
			printf("x = 2 est vrai.\n");
			else if (y < 8)
			printf("y < 8.\n");
			else if (y == 3)
			printf("y vaut 3 mais cela ne sera jamais affiché.\n");
			else
			printf("Ni l'un ni l'autre.\n");
			x = -1; // toujours évalué
			```

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

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


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

			## La boucle `while`{.C}

			```C
			while (condition) {
			instructions;
			}
			do {
			instructions;
			} while (condition);
			```

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

			```C
			int sum = 0; // syntaxe C99
			while (sum < 10) {
			sum += 1;
			}
			do {
			sum += 10;
			} while (sum < 100)
			```

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

			## La boucle `for`{.C}

			```C
			for (expression1; expression2; expression3) {
			instructions;
			}
			```

			## La boucle `for`{.C}

			```C
			int sum = 0; // syntaxe C99
			for (int i = 0; i < 10; i++) {
			sum += i;
			}

			for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
			printf("C'est plus ésotérique.\n");
			}
			```

slides/cours_10.md→slides_2022/cours_10.md

+0 −0

File moved.

slides/cours_11.md→slides_2022/cours_11.md

+0 −0

File moved.

slides/cours_12.md→slides_2022/cours_12.md

+0 −0

File moved.

slides/cours_13.md→slides_2022/cours_13.md

+0 −0

File moved.

slides/cours_14.md→slides_2022/cours_14.md

+0 −0

File moved.

slides/cours_15.md→slides_2022/cours_15.md

+0 −0

File moved.

slides/cours_16.md→slides_2022/cours_16.md

+0 −0

File moved.

slides/cours_17.md→slides_2022/cours_17.md

+0 −0

File moved.

slides/cours_18.md→slides_2022/cours_18.md

+0 −0

File moved.

slides/cours_19.md→slides_2022/cours_19.md

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -461,11 +461,12 @@ node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth)

	```C		```C
	matrice arbre_à_matrice(arbre)		matrice arbre_à_matrice(arbre)
			matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
	pour li de 0 à nb_lignes(matrice)		pour li de 0 à nb_lignes(matrice)
	pour co de 0 à nb_colonnes(matrice)		pour co de 0 à nb_colonnes(matrice)
	noeud = position(li, co, arbre)		noeud = position(li, co, arbre)
	matrice[co][li] = noeud.info		matrice[co][li] = noeud.info
	retourne arbre		retourne matrice
	```		```

	. . .		. . .

slides/cours_2.md→slides_2022/cours_2.md

+0 −0

File moved.

slides/cours_20.md→slides_2022/cours_20.md

+11 −11

Original line number	Original line	Diff line number	Diff line
	@@ -198,7 +198,7 @@ void rotate(node *qt) {
	}		}
	```		```

	# Compression sans perte (1/N)		# Compression sans perte (1/5)

	## Idée générale		## Idée générale

	@@ -216,7 +216,7 @@ void rotate(node *qt) {

	* Comment faire?		* Comment faire?

	# Compression sans perte (2/N)		# Compression sans perte (2/5)

	## Que devient l'arbre suivant?		## Que devient l'arbre suivant?

	@@ -228,7 +228,7 @@ void rotate(node *qt) {

	![](figs/quad_img_simple_comp.svg)		![](figs/quad_img_simple_comp.svg)

	# Compression sans perte (3/N)		# Compression sans perte (3/5)

	* Si un nœud a tous ses enfants égaux:		* Si un nœud a tous ses enfants égaux:
	* Donner la valeur au nœud,		* Donner la valeur au nœud,
	@@ -251,7 +251,7 @@ rien compression_sans_pertes(arbre)
	detruire_enfants(arbre)		detruire_enfants(arbre)
	```		```

	# Compression sans perte (4/N)		# Compression sans perte (4/5)

	\footnotesize		\footnotesize

	@@ -279,7 +279,7 @@ void lossless_compression(node *qt) {
	}		}
	```		```

	# Compression sans perte (5/N)		# Compression sans perte (5/5)

	\footnotesize		\footnotesize

	@@ -305,7 +305,7 @@ bool last_value(node qt, int val) {
	```		```


	# Compression avec perte (1/N)		# Compression avec perte (1/5)

	## Idée générale		## Idée générale

	@@ -323,7 +323,7 @@ bool last_value(node qt, int val) {

	* On enlève si l'écart à la moyenne est "petit"?		* On enlève si l'écart à la moyenne est "petit"?

	# Compression avec perte (2/N)		# Compression avec perte (2/5)

	## Que devient l'arbre suivant si l'écart est petit?		## Que devient l'arbre suivant si l'écart est petit?

	@@ -335,7 +335,7 @@ bool last_value(node qt, int val) {

	![](figs/quad_img_simple_comp_loss.svg)		![](figs/quad_img_simple_comp_loss.svg)

	# Compression avec perte (3/N)		# Compression avec perte (3/5)

	## Comment mesurer l'écart à la moyenne?		## Comment mesurer l'écart à la moyenne?

	@@ -362,7 +362,7 @@ bool last_value(node qt, int val) {

	* Plus $\theta$ est grand, plus l'image sera compressée.		* Plus $\theta$ est grand, plus l'image sera compressée.

	# Compression avec perte (4/N)		# Compression avec perte (4/5)

	## Que devient l'arbre avec $\theta=0.5$?		## Que devient l'arbre avec $\theta=0.5$?

	@@ -372,7 +372,7 @@ bool last_value(node qt, int val) {

	![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)		![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)

	# Compression avec perte (6/N)		# Compression avec perte (5/5)

	## Modifications sur la structure de données?		## Modifications sur la structure de données?

	@@ -429,7 +429,7 @@ rien compression_avec_pertes(arbre, theta)
	```C		```C
	arbre = matrice_à_arbre(matrice)		arbre = matrice_à_arbre(matrice)
	moyenne(arbre)		moyenne(arbre)
	compression_sans_pertes(arbre)		compression_avec_pertes(arbre)
	```		```

	# La dynamique des corps célestes		# La dynamique des corps célestes

slides/cours_21.md→slides_2022/cours_21.md

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -619,7 +619,7 @@ rien maj_force_sur_etoile(arbre, e, theta)

	## Exemples d'insertion: `5`		## Exemples d'insertion: `5`

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

	. . .		. . .

	@@ -641,7 +641,7 @@ rien maj_force_sur_etoile(arbre, e, theta)

	## Exemples d'insertion: `6`		## Exemples d'insertion: `6`

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

	. . .		. . .

	@@ -660,7 +660,7 @@ rien maj_force_sur_etoile(arbre, e, theta)

	## Exemples d'insertion: `7`		## Exemples d'insertion: `7`

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

	. . .		. . .

slides_2022/cours_22.md

0 → 100644

+351 −0

Original line number	Original line	Diff line number	Diff line
			---
			title: "B-arbres"
			date: "2023-05-19"
			---

			# Rappel: Les B-arbres

			## Pourquoi utiliser un B-arbre?

			. . .

			## À quoi ressemble un B-arbre?

			. . .

			## Qu'est-ce qu'un 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.


			# Rappel: Les B-arbres

			## Quelques propriétés

			* Dans chaque nœud les clés sont triées.
			* Chaque page contient au plus $n$ nœuds;
			* Chaque nœud avec $m$ clés a $m+1$ descendants;
			* Toutes les feuilles apparaissent au même niveau.

			# Les B-arbres

			\footnotesize

			## Structure de données

			* Chaque page a une contrainte de remplissage, par rapport à l'ordre de l'arbre;
			* Un nœud (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)?

			. . .

			![Structure 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 nœud 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 nœud 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 nœud 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 nœud plein, promotion `3`?

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

			. . .

			## Solution

			![](figs/barbres_insert_hard_after.svg)

			# Les B-arbres

			## L'insertion cas nœud 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 valeur médiane `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
			entier 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 && valeur >= 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) // créer une page
			rien liberer_memoire(page) // libérer 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) - 1], valeur)
			```

			# Les B-arbres

			## Les fonctions

			```C
			page inserer_valeur(page, valeur) // insérer une valeur
			```

			. . .

			```C
			page inserer_valeur(page, valeur)
			element = nouvel_element(valeur)
			// ici élément est modifié 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) // insérer 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.clé) - 1].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)
			nouvelle_page = nouvelle_page(page.ordre)
			nouvelle_page.nb = page.ordre
			pour i de 0 à ordre inclu
			nouvelle_page.tab[i] = page.tab[i+ordre+1]
			element.clé = page.tab[ordre+1].clé
			element.page = nouvelle_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_2022/cours_23.md

0 → 100644

+1013 −0

Original line number	Original line	Diff line number	Diff line
			---
			title: "B-arbres et Graphes"
			date: "2023-05-24"
			patat:
			eval:
			tai:
			command: fish
			fragment: false
			replace: true
			ccc:
			command: fish
			fragment: false
			replace: true
			images:
			backend: auto
			---


			# Les B-arbres: suppression

			## Cas simplissime

			![Suppression de 25.](figs/barbres_ordre2_supp1.svg){width=80%}

			. . .

			![25 supprimé, on décale juste 27.](figs/barbres_ordre2_supp2.svg){width=80%}

			# Les B-arbres: suppression

			\footnotesize

			## Cas simple


			![Suppression de 27.](figs/barbres_ordre2_supp2.svg){width=60%}

			. . .

			* On retire 27, mais....
			* Chaque page doit avoir au moins 2 éléments.
			* On doit déplacer des éléments dans une autre feuille! Mais comment?

			. . .

			![La médiane de la racine descend, fusion de 20 à gauche, et suppression à droite.](figs/barbres_ordre2_supp3.svg){width=60%}

			# Les B-arbres: suppression

			## Cas moins simple

			![Suppression de 5.](figs/barbres_ordre2_supp4.svg){width=60%}

			. . .

			* Un élément à droite, comment on fait?
			* Remonter `7`, serait ok si racine, mais... c'est pas forcément.
			* On redistribue les feuilles.

Compare revisions

Source

Target

Files

Some changes are not shown.

README.md

slides/.gitignore

slides/Makefile

slides/cours_1.md

slides/intro.md

slides/metadata.yaml

slides_2022/Makefile

slides_2022/cours_1.md

slides/cours_10.md→slides_2022/cours_10.md

slides/cours_11.md→slides_2022/cours_11.md

slides/cours_12.md→slides_2022/cours_12.md

slides/cours_13.md→slides_2022/cours_13.md

slides/cours_14.md→slides_2022/cours_14.md

slides/cours_15.md→slides_2022/cours_15.md

slides/cours_16.md→slides_2022/cours_16.md

slides/cours_17.md→slides_2022/cours_17.md

slides/cours_18.md→slides_2022/cours_18.md

slides/cours_19.md→slides_2022/cours_19.md

slides/cours_2.md→slides_2022/cours_2.md

slides/cours_20.md→slides_2022/cours_20.md

slides/cours_21.md→slides_2022/cours_21.md

slides_2022/cours_22.md

slides_2022/cours_23.md