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
  • algorithmique/cours
  • aurelien.boyer/cours
  • jeremy.meissner/cours
  • radhwan.hassine/cours
  • yassin.elhakoun/cours-algo
  • gaspard.legouic/cours
  • joachim.bach/cours
  • gabriel.marinoja/algo-cours
  • loic.lavorel/cours
  • iliya.saroukha/cours
  • costanti.volta/cours
  • jacquesw.ndoumben/cours
12 results
Select Git revision
  • master
  • yassin.elhakoun-master-patch-05495
  • yassin.elhakoun-master-patch-06640
  • yassin.elhakoun-master-patch-26727
  • yassin.elhakoun-master-patch-35538
  • yassin.elhakoun-master-patch-76337
6 results
Show changes
Commits on Source (130)
30 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 7230 additions and 5877 deletions
slides/.clang-format 0 → 100644
View file @ febfc3f8
---
Language: Cpp
# BasedOnStyle: Google
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignConsecutiveMacros: true
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortLambdasOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: MultiLine
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: AfterColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: AfterColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 100
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: false
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
SortPriority: 0
- Regex: '^<.*\.h>'
Priority: 1
SortPriority: 0
- Regex: '^<.*'
Priority: 2
SortPriority: 0
- Regex: '.*'
Priority: 3
SortPriority: 0
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: false
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentWidth: 4
IndentWrappedFunctionNames: true
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Right
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
- ParseTestProto
- ParsePartialTestProto
CanonicalDelimiter: ''
BasedOnStyle: google
ReflowComments: true
SortIncludes: false
SortUsingDeclarations: false
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Auto
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 4
UseCRLF: false
UseTab: Never
WhitespaceSensitiveMacros:
- STRINGIZE
- PP_STRINGIZE
- BOOST_PP_STRINGIZE
...
slides/.gitignore
View file @ febfc3f8
*.pdf
*.err
*.markdown
*.html
index.md
diagram*.pdf
cours*.pdf
intro.pdf
mermaid-filter.err
.puppeteer.json
slides/Makefile
View file @ febfc3f8
......@@ -18,14 +18,15 @@ all: puppeteer $(PDF)
# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf
docker: docker-compose.yml
docker-compose run slides
docker compose run slides
docker_clean: docker-compose.yml
docker-compose run slides clean
docker compose run slides clean
puppeteer:
@echo "Setting chromium to $(CHROMIUM) for puppeteer"
@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
# @echo "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
index.md: gen_index.sh
$(shell ./gen_index.sh)
......
slides/cours_1.md
View file @ febfc3f8
---
title: "Introduction aux algorithmes"
date: "2023-09-19"
title: "Introduction aux algorithmes I"
date: "2024-09-16"
---
# Qu'est-ce qu'un algorithme?
......
slides/cours_10.md
View file @ febfc3f8
---
title: "Piles"
date: "2023-12-05"
title: "Backtracking et piles"
date: "2024-12-02"
---
# Rappel
# Le problème des 8-reines
## Qu'est-ce qu'une pile?
\Huge Le problème des 8-reines
# Problème des 8-reines
* Placer 8 reines sur un échiquier de $8 \times 8$.
* Sans que les reines ne puissent se menacer mutuellement (92 solutions).
## Conséquence
* Deux reines ne partagent pas la même rangée, colonne, ou diagonale.
* Donc chaque solution a **une** reine **par colonne** ou **ligne**.
## Généralisation
* Placer $N$ reines sur un échiquier de $N \times
N$.
- Exemple de **backtracking** (retour en arrière) $\Rightarrow$ récursivité.
![Problème des 8-reines. Source:
[wikipedia](https://fr.wikipedia.org/wiki/Problème_des_huit_dames)](./figs/fig_recursivite_8_reines.png){width=35%}
# Problème des 2-reines
![Le problème des 2 reines n'a pas de solution.](figs/2reines.svg){width=50%}
# Comment trouver les solutions?
* On pose la première reine sur la première case disponible.
* On rend inaccessibles toutes les cases menacées.
* On pose la reine suivante sur la prochaine case non-menacée.
* Jusqu'à ce qu'on puisse plus poser de reine.
* On revient alors en arrière jusqu'au dernier coup où il y avait plus qu'une
possibilité de poser une reine.
* On recommence depuis là.
. . .
* Structure de données LIFO.
* Le jeu prend fin quand on a énuméré *toutes* les possibilités de poser les
reines.
# Problème des 3-reines
![Le problème des 3 reines n'a pas de solution non plus.](figs/3reines.svg)
# Problème des 4-reines
![Le problème des 4 reines a une solution.](figs/4reines.svg)
# Problème des 4-reines, symétrie
![Le problème des 4 reines a une autre solution (symétrie
horizontale).](figs/4reines_sym.svg)
# Problème des 5 reines
## Exercice: Trouver une solution au problème des 5 reines
* Faire une capture d'écran / une photo de votre solution et la poster sur
matrix.
```C
## Quelles fonctionnalités?
```
# Quelques observations sur le problème
* Une reine par colonne au plus.
* On place les reines sur des colonnes successives.
* On a pas besoin de "regarder en arrière" (on place "devant" uniquement).
* Trois étapes:
* On place une reine dans une case libre.
* On met à jour le tableau.
* Quand on a plus de cases libres on "revient dans le temps" ou c'est qu'on
a réussi.
# Le code du problème des 8 reines (1/5)
## Quelle structure de données?
. . .
1. Empiler (push): ajouter un élément sur la pile.
2. Dépiler (pop): retirer l'élément du sommet de la pile et le retrouner.
3. Liste vide? (is_empty?).
4. Jeter un oeil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
5. Nombre d'éléments (length).
Une matrice de booléens fera l'affaire:
# Structure de données (1/2)
```C
bool board[n][n];
```
## Struct `stack`
## Quelles fonctionnalités?
. . .
```C
#define MAX_CAPACITY 500
typedef struct _stack {
int data[MAX_CAPACITY]; // les données
int top; // indice du sommet
} stack;
// Pour chaque ligne placer la reine sur toutes les colonnes
// et compter les solutions
void nbr_solutions(board, column, counter);
// Copier un tableau dans un autre
void copy(board_in, board_out);
// Placer la reine à li, co et rendre inaccessible devant
void placer_devant(board, li, co);
```
# Structure de données (2/2)
# Le code du problème des 8 reines (2/5)
## Fonctions `stack`
## Le calcul du nombre de solutions
. . .
```C
// Calcule le nombre de solutions au problème des <n> reines
rien nbr_solutions(board, column, count)
pour chaque ligne
si la case libre
si column < n - 1
copier board dans un "new" board,
y poser une reine
et mettre à jour ce "new" board
nbr_solutions(new_board, column+1, count)
sinon
on a posé la n-ème et on a gagné
count += 1
```
# Le code du problème des 8 reines (3/5)
## Le calcul du nombre de solutions
```C
void stack_init(stack *s) {
s->top = -1;
}
bool stack_is_empty(stack s) {
return s.top == -1;
}
void stack_push(stack *s, int val) {
s->top += 1;
s->data[s->top] = val;
}
int stack_pop(stack *s) {
s->top -= 1;
return s->data[s->top+1];
}
// Placer une reine et mettre à jour
rien placer_devant(board, ligne, colonne)
board est occupé à ligne/colonne
toutes les cases des colonnes
suivantes sont mises à jour
```
# La pile dynamique
# Le code du problème des 8 reines (4/5)
## Comment modifier le code précédent pour avoir une taille dynamique?
## Compris? Alors écrivez le code et postez le!
. . .
## Le nombre de solutions
\footnotesize
```C
// alloue une zone mémoire de size octets
void *malloc(size_t size);
// change la taille allouée à size octets (contiguïté garantie)
void *realloc(void *ptr, size_t size);
// Calcule le nombre de solutions au problème des <n> reines
void nb_sol(int n, bool board[n][n], int co, int *ptr_cpt) {
for (int li = 0; li < n; li++) {
if (board[li][co]) {
if (co < n-1) {
bool new_board[n][n]; // alloué à chaque nouvelle tentative
copy(n, board, new_board);
prises_devant(n, new_board, li, co);
nb_sol(n, new_board, co+1, ptr_cpt);
} else {
*ptr_cpt = (*ptr_cpt)+1;
}
}
}
}
```
. . .
**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
# Le code du problème des 8 reines (5/5)
## Et maintenant?
\footnotesize
. . .
## Placer devant
```C
void stack_create(stack *s); // crée une pile avec une taille par défaut
// vérifie si la pile est pleine et réalloue si besoin
void stack_push(stack *s, int val);
// vérifie si la pile est vide/trop grande
// et réalloue si besoin
void stack_pop(stack *s, int *ret);
// Retourne une copie du tableau <board> complété avec les positions
// prises sur la droite droite par une reine placée en <board(li,co)>
void placer_devant(int n, bool board[n][n], int li, int co) {
board[li][co] = false; // position de la reine
for (int j = 1; j < n-co; j++) {
// horizontale et diagonales à droite de la reine
if (j <= li) {
board[li-j][co+j] = false;
}
board[li][co+j] = false;
if (li+j < n) {
board[li+j][co+j] = false;
}
}
}
```
. . .
# Les piles
\Huge Les piles
# Les piles (1/5)
## Faisons l'implémentation ensemble
## Qu'est-ce donc?
# Le tri à deux piles (1/3)
* Structure de données abstraite...
## Cas pratique
. . .
![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}
* de type `LIFO` (*Last in first out*).
# Le tri à deux piles (2/3)
![Une pile où on ajoute A, puis B avant de les retirer. Source:
[Wikipedia](https://upload.wikimedia.org/wikipedia/commons/e/e1/Stack_(data_structure)_LIFO.svg)](figs/Stack.svg){width=70%}
## Exercice: formaliser l'algorithme
## Des exemples de la vraie vie
. . .
## Algorithme de tri nécessitant 2 piles (G, D)
* Pile d'assiettes, de livres, ...
* Adresses visitées par un navigateur web.
* Les calculatrices du passé (en polonaise inverse).
* Les boutons *undo* de vos éditeurs de texte (aka *u* dans vim).
Soit `tab` le tableau à trier:
# Les piles (2/5)
```C
pour i de 0 à N-1
tant que (tab[i] > que le sommet de G)
dépiler G dans D
tant que (tab[i] < que le sommet de D)
dépiler de D dans G
empiler tab[i] sur G
dépiler tout D dans G
tab est trié dans G
```
## Fonctionnalités
# Le tri à deux piles (3/3)
. . .
## Exercice: trier le tableau `[2, 10, 5, 20, 15]`
1. Empiler (push): ajouter un élément sur la pile.
2. Dépiler (pop): retirer l'élément du sommet de la pile et le retourner.
3. Pile vide? (is_empty?).
```C
. . .
4. Jeter un œil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
5. Nombre d'éléments (length).
## Comment faire les 4, 5 à partir de 1 à 3?
. . .
4. Dépiler l'élément, le copier, puis l'empiler à nouveau.
5. Dépiler jusqu'à ce que la pile soit vide, puis empiler à nouveau.
. . .
## Existe en deux goûts
* Pile avec ou sans limite de capacité (à concurrence de la taille de la
mémoire).
# Les piles (3/5)
## Implémentation
* Jusqu'ici on n'a pas du tout parlé d'implémentation (d'où le nom de structure
abstraite).
* Pas de choix unique d'implémentation.
## Quelle structure de données allons nous utiliser?
. . .
Et oui vous avez deviné: un tableau!
## La structure: de quoi avons-nous besoin (pile de taille fixe)?
. . .
```C
#define MAX_CAPACITY 500
typedef struct _stack {
int data[MAX_CAPACITY]; // les données
int top; // indice du sommet
} stack;
```
# La calculatrice (1/8)
# Les piles (4/5)
## Vocabulaire
## Initialisation
. . .
```C
2 + 3 = 2 3 +,
void stack_init(stack *s) {
s->top = -1;
}
```
`2` et `3` sont les *opérandes*, `+` l'*opérateur*.
## Est vide?
. . .
## La notation infixe
```C
2 * (3 + 2) - 4 = 6.
bool stack_is_empty(stack s) {
return s.top == -1;
}
```
## La notation postfixe
## Empiler (ajouter un élément au sommet)
. . .
```C
2 3 2 + * 4 - = 6.
void stack_push(stack *s, int val) {
s->top += 1;
s->data[s->top] = val;
}
```
## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`
# Les piles (5/5)
## Dépiler (enlever l'élément du sommet)
. . .
```C
2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
int stack_pop(stack *s) {
s->top -= 1;
return s->data[s->top+1];
}
```
# La calculatrice (2/8)
## Jeter un oeil (regarder le sommet)
## De infixe à post-fixe
* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.
* Les opérateurs on des *priorités* différentes.
. . .
```C
^ : priorité 3
* / : priorité 2
+ - : priorité 1
( ) : priorité 0 // pas un opérateur mais bon
int stack_peek(stack s) {
return s.data[s.top];
}
```
## Quelle est la complexité de ces opérations?
. . .
## Voyez-vous des problèmes potentiels avec cette implémentation?
# La calculatrice (3/8)
. . .
## De infixe à post-fixe: algorithme
* Empiler avec une pile pleine.
* Dépiler avec une pile vide.
* Jeter un oeil au sommet d'une pile vide.
* On lit l'expression infixe de gauche à droite.
# Gestion d'erreur, level 0
* On examine le prochain caractère de l'expression infixe.
* Si opérande, le placer dans l'expression du résultat.
* Si parenthèse le mettre dans la pile (priorité 0).
* Si opérateur, comparer sa priorité avec celui du sommet de la pile:
* Si sa priorité est plus élevée, empiler.
* Sinon dépiler l'opérateur de la pile dans l'expression du résultat et
recommencer jusqu'à apparition d'un opérateur de priorité plus faible
au sommet de la pile (ou pile vide).
* Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les
placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse
ouverte apparaisse au sommet, dépiler également la parenthèse.
* Si il n'y a pas de caractère dans l'expression dépiler tous les
opérateurs dans le résultat.
* Il y a plusieurs façon de traiter les erreur:
* Ne rien faire (laisser la responsabilité à l'utilisateur).
* Faire paniquer le programme (il plante plus ou moins violemment).
* Utiliser des codes d'erreurs.
# La calculatrice (4/8)
## La panique
## De infixe à post-fixe: exemple
* En C, on a les `assert()` pour faire paniquer un programme.
```C
Infixe Postfixe Pile Priorité
((A*B)/D-F)/(G+H) Vide Vide Néant
(A*B)/D-F)/(G+H) Vide ( 0
A*B)/D-F)/(G+H) Vide (( 0
*B)/D-F)/(G+H) A (( 0
B)/D-F)/(G+H) A ((* 2
)/D-F)/(G+H) AB ((* 2
/D-F)/(G+H) AB* ( 0
D-F)/(G+H) AB* (/ 2
-F)/(G+H) AB*D (/ 2
F)/(G+H) AB*D/ (- 1
)/(G+H) AB*D/F (- 1
/(G+H) AB*D/F- Vide Néant
```
# Les assertions
# La calculatrice (5/8)
\Huge Les assertions
## De infixe à post-fixe: exemple
# Assertions (1/3)
```C
Infixe Postfixe Pile Priorité
((A*B)/D-F)/(G+H) Vide Vide Néant
--------------------------------------------------------
/(G+H) AB*D/F- Vide Néant
(G+H) AB*D/F- / 2
G+H) AB*D/F- /( 0
+H) AB*D/F-G /( 0
H) AB*D/F-G /(+ 1
) AB*D/F-GH /(+ 1
Vide AB*D/F-GH+ / 2
Vide AB*D/F-GH+/ Vide Néant
#include <assert.h>
void assert(int expression);
```
# La calculatrice (6/8)
## Qu'est-ce donc?
\footnotesize
- Macro permettant de tester une condition lors de l'exécution d'un programme:
- Si `expression == 0`{.C} (condition fausse), `assert()`{.C} affiche un message d'erreur sur `stderr`{.C} et termine l'exécution du programme.
- Sinon l'exécution se poursuit normalement.
- Peuvent être désactivés à la compilation avec `-DNDEBUG` (équivalent à `#define NDEBUG`)
## Exercice: écrire le code et le poster sur matrix
## À quoi ça sert?
* Quelle est la signature de la fonction?
- Permet de réaliser des tests unitaires.
- Permet de tester des conditions catastrophiques d'un programme.
- **Ne permet pas** de gérer les erreurs.
. . .
# Assertions (2/3)
* Une sorte de corrigé:
<!-- \footnotesize -->
## Exemple
```C
char *infix_to_postfix(char* infix) { // init and alloc stack and postfix
for (size_t i = 0; i < strlen(infix); ++i) {
if (is_operand(infix[i])) {
// we just add operands in the new postfix string
} else if (infix[i] == '(') {
// we push opening parenthesis into the stack
} else if (infix[i] == ')') {
// we pop everything into the postfix
} else if (is_operator(infix[i])) {
// this is an operator. We add it to the postfix based
// on the priority of what is already in the stack and push it
}
}
// pop all the operators from the s at the end of postfix
// and end the postfix with `\0`
return postfix;
}
#include <assert.h>
void stack_push(stack *s, int val) {
assert(s->top < MAX_CAPACITY-1);
s->top += 1;
s->data[s->top] = val;
}
int stack_pop(stack *s) {
assert(s->top >= 0);
s->top -= 1;
return s->data[s->top+1];
}
int stack_peek(stack *s) {
assert(s->top >= 0);
return s->data[s->top];
}
```
# Assertions (3/3)
# La calculatrice (7/8)
## Cas typiques d'utilisation
## Évaluation d'expression postfixe: algorithme
- Vérification de la validité des pointeurs (typiquement `!= NULL`{.C}).
- Vérification du domaine des indices (dépassement de tableau).
* Chaque *opérateur* porte sur les deux opérandes qui le précèdent.
* Le *résultat d'une opération* est un nouvel *opérande* qui est remis au
sommet de la pile.
## Bug vs. erreur de *runtime*
## Exemple
- Les assertions sont là pour détecter les bugs (erreurs d'implémentation).
- Les assertions ne sont pas là pour gérer les problèmes externes au programme (allocation mémoire qui échoue, mauvais paramètre d'entrée passé par l'utilisateur, ...).
```C
2 3 4 + * 5 - = ?
```
. . .
- Mais peuvent être pratiques quand même pour ça...
- Typiquement désactivées dans le code de production.
* On parcours de gauche à droite:
# La pile dynamique
## Comment modifier le code précédent pour avoir une taille dynamique?
. . .
```C
Caractère lu Pile opérandes
2 2
3 2, 3
4 2, 3, 4
+ 2, (3 + 4)
* 2 * 7
5 14, 5
- 14 - 5 = 9
// alloue une zone mémoire de size octets
void *malloc(size_t size);
// change la taille allouée à size octets (contiguïté garantie)
void *realloc(void *ptr, size_t size);
```
# La calculatrice (8/8)
## Évaluation d'expression postfixe: algorithme
. . .
1. La valeur d'un opérande est *toujours* empilée.
2. L'opérateur s'applique *toujours* au 2 opérandes au sommet.
3. Le résultat est remis au sommet.
**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
## Exercice: écrire l'algorithme en C (et poster sur matrix)
## Et maintenant?
. . .
```C
bool evaluate(char *postfix, double *val) { // init stack
for (size_t i = 0; i < strlen(postfix); ++i) {
if (is_operand(postfix[i])) {
stack_push(&s, postfix[i]);
} else if (is_operator(postfix[i])) {
double rhs = stack_pop(&s);
double lhs = stack_pop(&s);
stack_push(&s, op(postfix[i], lhs, rhs));
}
}
return stack_pop(&s);
}
void stack_create(stack *s); // crée une pile avec une taille par défaut
// vérifie si la pile est pleine et réalloue si besoin
void stack_push(stack *s, int val);
// vérifie si la pile est vide/trop grande
// et réalloue si besoin
void stack_pop(stack *s, int *ret);
```
. . .
## Faisons s'implémentation ensemble
slides/cours_11.md
View file @ febfc3f8
---
title: "Calculatrices, liste chaînée, et files d'attente"
date: "2023-12-12"
title: "Applications des piles, listes chaînées et files d'attente"
date: "2024-12-09"
---
# La calculatrice (Rappel)
# Rappel: les piles
## Écrire `2 * 3 * 4 + 2` en notation `postfixe`
## Qu'est-ce donc?
. . .
* Structure de données abstraite de type LIFO
## Quelles fonctionnalités?
. . .
1. Empiler (push): ajouter un élément sur la pile.
2. Dépiler (pop): retirer l'élément du sommet de la pile et le retourner.
3. Pile vide? (is_empty?).
# Le tri à deux piles
\Huge Le tri à deux piles
# Le tri à deux piles (1/3)
## Cas pratique
![Un exemple de tri à deux piles](figs/tri_piles.svg){width=70%}
# Le tri à deux piles (2/3)
## Exercice: formaliser l'algorithme
. . .
## Algorithme de tri nécessitant 2 piles (G, D)
Soit `tab` le tableau à trier:
```C
2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
pour i de 0 à N-1
tant que (tab[i] > que le sommet de G)
dépiler G dans D
tant que (tab[i] < que le sommet de D)
dépiler de D dans G
empiler tab[i] sur G
dépiler tout D dans G
dépiler tout G dans tab
```
# Le tri à deux piles (3/3)
## Exercice: trier le tableau `[2, 10, 5, 20, 15]`
```C
```
# La Calculatrice
\Huge La Calculatrice
# La calculatrice (1/8)
## Vocabulaire
```C
2 + 3 = 2 3 +,
```
## Quelle structure de données utiliser pour la calculatrice?
`2` et `3` sont les *opérandes*, `+` l'*opérateur*.
. . .
La pile!
## La notation infixe
```C
2 * (3 + 2) - 4 = 6.
```
# La calculatrice (Rappel 2)
## La notation postfixe
```C
2 3 2 + * 4 - = 6.
```
## Exercice: écrire `2 * 3 * 4 + 2` en notation `postfixe`
. . .
```C
2 3 4 * * 2 + = (2 * (3 * 4)) + 2.
```
# La calculatrice (2/8)
## De infixe à post-fixe
* Une *pile* est utilisée pour stocker *opérateurs* et *parenthèses*.
* Les opérateurs ont des *priorités* différentes.
```C
^ : priorité 3
* / : priorité 2
+ - : priorité 1
( ) : priorité 0 // pas un opérateur mais bon
```
# La calculatrice (3/8)
## De infixe à post-fixe: algorithme
* On lit l'expression infixe de gauche à droite.
* On examine le prochain caractère de l'expression infixe:
* Si opérande, le placer dans l'expression du résultat.
* Si parenthèse le mettre dans la pile (priorité 0).
* Si opérateur, comparer sa priorité avec celui du sommet de la pile:
* Si sa priorité est plus élevée, empiler.
* Sinon dépiler l'opérateur de la pile dans l'expression du résultat et
recommencer jusqu'à apparition d'un opérateur de priorité plus faible
au sommet de la pile (ou pile vide).
* Si parenthèse fermée, dépiler les opérateurs du sommet de la pile et les
placer dans l'expression du résultat, jusqu'à ce qu'une parenthèse
ouverte apparaisse au sommet, dépiler également la parenthèse.
* Si il n'y a pas de caractère dans l'expression dépiler tous les
opérateurs dans le résultat.
# La calculatrice (4/8)
## De infixe à post-fixe: exemple
```C
Infixe Postfixe Pile Priorité
((A*B)/D-F)/(G+H) Vide Vide Néant
(A*B)/D-F)/(G+H) Vide ( 0
A*B)/D-F)/(G+H) Vide (( 0
*B)/D-F)/(G+H) A (( 0
B)/D-F)/(G+H) A ((* 2
)/D-F)/(G+H) AB ((* 2
/D-F)/(G+H) AB* ( 0
D-F)/(G+H) AB* (/ 2
-F)/(G+H) AB*D (/ 2
F)/(G+H) AB*D/ (- 1
)/(G+H) AB*D/F (- 1
/(G+H) AB*D/F- Vide Néant
```
# La calculatrice (5/8)
## De infixe à post-fixe: exemple
```C
Infixe Postfixe Pile Priorité
((A*B)/D-F)/(G+H) Vide Vide Néant
--------------------------------------------------------
/(G+H) AB*D/F- Vide Néant
(G+H) AB*D/F- / 2
G+H) AB*D/F- /( 0
+H) AB*D/F-G /( 0
H) AB*D/F-G /(+ 1
) AB*D/F-GH /(+ 1
Vide AB*D/F-GH+ / 2
Vide AB*D/F-GH+/ Vide Néant
```
# La calculatrice (6/8)
\footnotesize
## Quel est l'algorithme pour `infix_to_postfix`?
## Exercice: écrire le code et le poster sur matrix
* Quelle est la signature de la fonction?
. . .
* Une sorte de corrigé:
```C
char *infix_to_postfix(char* infix) { // init and alloc stack and postfix
char* infix_to_postfix(char* infix) { // init and alloc stack and postfix
for (size_t i = 0; i < strlen(infix); ++i) {
if (is_operand(infix[i])) {
// we just add operands in the new postfix string
......@@ -48,7 +215,7 @@ char *infix_to_postfix(char* infix) { // init and alloc stack and postfix
```
# La calculatrice (nouveautés)
# La calculatrice (7/8)
## Évaluation d'expression postfixe: algorithme
......@@ -75,7 +242,7 @@ Caractère lu Pile opérandes
- 14 - 5 = 9
```
# La calculatrice (nouveautés 2)
# La calculatrice (8/8)
## Évaluation d'expression postfixe: algorithme
......@@ -88,7 +255,8 @@ Caractère lu Pile opérandes
. . .
```C
double evaluate(char *postfix) { // init stack
double evaluate(char* postfix) {
// declare and initialize stack s
for (size_t i = 0; i < strlen(postfix); ++i) {
if (is_operand(postfix[i])) {
stack_push(&s, postfix[i]);
......@@ -102,7 +270,9 @@ double evaluate(char *postfix) { // init stack
}
```
# Liste chaînée et pile
\Huge Liste chaînée et pile
# La liste chaînée et pile (1/6)
......@@ -124,7 +294,9 @@ typedef struct _element {
int data;
struct _element *next;
} element;
typedef element* stack;
typedef struct _stack {
element *top;
} stack;
```
## Fonctionnalités?
......@@ -132,12 +304,12 @@ typedef element* stack;
. . .
```C
void stack_create(stack *s); // *s = NULL;
void stack_create(stack *s); // s->top = NULL;
void stack_destroy(stack *s);
void stack_push(stack *s, int val);
void stack_pop(stack *s, int *val);
void stack_peek(stack s, int *val);
bool stack_is_empty(stack s); // reutrn NULL == stack;
bool stack_is_empty(stack s); // return NULL == s.top;
```
# La liste chaînée et pile (3/6)
......@@ -164,8 +336,8 @@ bool stack_is_empty(stack s); // reutrn NULL == stack;
void stack_push(stack *s, int val) {
element *elem = malloc(sizeof(*elem));
elem->data = val;
elem->next = *s;
*s = elem;
elem->next = s->top;
s->top = elem;
}
```
......@@ -191,7 +363,7 @@ void stack_push(stack *s, int val) {
```C
void stack_peek(stack s, int *val) {
*val = s->data;
*val = s.top->val;
}
```
......@@ -218,8 +390,8 @@ void stack_peek(stack s, int *val) {
```C
void stack_pop(stack *s, int *val) {
stack_peek(*s, val);
element *tmp = *s;
*s = (*s)->next;
element *tmp = s->top;
s->top = s->top->next;
free(tmp);
}
```
......@@ -253,513 +425,3 @@ void stack_destroy(stack *s) {
}
```
# La file d'attente (1/N)
* Structure de données abstraite permettant le stockage d'éléments.
* *FIFO*: First In First Out, ou première entrée première sortie.
* Analogue de la vie "réelle"":
* File à un guichet,
* Serveur d'impressions,
* Mémoire tampon, ...
## Fonctionnalités
. . .
* Enfiler: ajouter un élément à la fin de la file.
* Défiler: extraire un élément au devant de la file.
* Tester si la file est vide.
. . .
* Lire l'élément de la fin de la file.
* Lire l'élément du devant de la file.
* Créer une liste vide.
* Détruire une liste vide.
# La file d'attente (2/N)
\footnotesize
## Implémentation possible
* La structure file, contient un pointeur vers la tête et un vers le début de la file.
* Entre les deux, les éléments sont stockés dans une liste chaînée.
![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}
## Structure de données en C?
. . .
```C
typedef struct _element { // Elément de liste
int data;
struct _element* next;
} element;
typedef struct _queue { // File d'attente:
element* head; // tête de file d'attente
element* tail; // queue de file d'attente
} queue;
```
# Fonctionnalités d'une file d'attente
## Creation et consultations
. . .
```C
void queue_init(queue *fa); // head = tail = NULL
bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL
int queue_tail(queue fa); // return fa.tail->data
int queue_head(queue fa); // return fa.head->data
```
## Manipulations et destruction
. . .
```C
void queue_enqueue(queue *fa, int val);
// adds an element before the tail
int queue_dequeue(queue *fa);
// removes the head and returns stored value
void queue_destroy(queue *fa);
// dequeues everything into oblivion
```
# Enfilage
## Deux cas différents:
1. La file est vide (faire un dessin):
. . .
![Insertion dans une file d'attente vide.](./figs/fig_empty_queue_insert.png){width=40%}
2. La file n'est pas vide (faire un dessin):
. . .
![Insertion dans une file d'attente non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
# Enfilage
## Live (implémentation)
. . .
```C
void queue_enqueue(queue *fa, int val) {
element* elmt = malloc(sizeof(*elmt));
elmt->data = val;
elmt->next = NULL;
if (queue_is_empty(*fa)) {
fa->head = elmt;
fa->tail = elmt;
} else {
fa->tail->next = elmt;
fa->tail = elmt;
}
}
```
# Défilage
## Trois cas différents
1. La file a plus d'un élément (faire un dessin):
. . .
![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}
2. La file un seul élément (faire un dessin):
. . .
![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
3. La file est vide (problème)
# Défilage
## Live (implémentation)
. . .
```C
int queue_dequeue(queue *fa) {
element* elmt = fa->head;
int val = elmt->data;
fa->head = fa->head->next;
free(elmt);
if (NULL == fa->head) {
fa->tail = NULL;
}
return val;
}
```
. . .
## Problème avec cette implémentation?
# Destruction
## Comment on faire la désallocation?
. . .
On défile jusqu'à ce que la file soit vide!
# Complexité
## Quelle sont les complexité de:
* Enfiler?
. . .
* Défiler?
. . .
* Détruire?
. . .
* Est vide?
# Implémentation alternative
## Comment implémenter la file autrement?
. . .
* Données stockées dans un tableau;
* Tableau de taille connue à la compilation ou pas (réallouable);
* `tail` seraient les indices du tableau;
* `capacity` seraient la capacité maximale;
* On *enfile* "au bout" du tableau, au défile au début (indice `0`).
. . .
## Structure de données
```C
typedef struct _queue {
int *data;
int tail, capacity;
} queue;
```
# File basée sur un tableau
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Enfiler?
. . .
```C
```
* Défiler?
. . .
```C
```
# Complexité
## Quelle sont les complexités de:
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Enfiler?
. . .
```C
```
* Défiler?
. . .
```C
```
# Une file plus efficace
## Comment faire une file plus efficace?
* Où est-ce que ça coince?
. . .
* Défiler est particulièrement lent $\mathcal{O}(N)$.
## Solution?
. . .
* Utiliser un indice séparé pour `head`.
```C
typedef struct _queue {
int *data;
int head, tail, capacity;
} queue;
```
# Une file plus efficace (implémentation)
## Enfilage
\footnotesize
```C
void queue_enqueue(queue *fa, int val) {
if ((fa->head == 0 && fa->tail == fa->capacity-1) ||
(fa->tail == (fa->head-1) % (fa->capacity-1))) {
return; // queue is full
}
if (fa->head == -1) { // queue was empty
fa->head = fa->tail = 0;
fa->data[fa->tail] = val;
} else if (fa->tail == fa->capacity-1 && fa->head != 0) {
// the tail reached the end of the array
fa->tail = 0;
fa->data[fa->tail] = val;
} else {
// nothing particular
fa->tail += 1;
fa->data[fa->tail] = val;
}
}
```
# Une file plus efficace (implémentation)
## Défilage
```C
void queue_dequeue(queue *fa, int *val) {
if (queue_is_empty(*fa)) {
return; // queue is empty
}
*val = fa->data[fa->head];
if (fa->head == fa->tail) { // that was the last element
fa->head = fa->tail = -1;
} else if (fa->head == fa->capacity-1) {
fa->head = 0;
} else {
fa->head += 1;
}
}
```
# Les listes triées
Une liste chaînée triée est:
* une liste chaînée
* dont les éléments sont insérés dans l'ordre.
![Exemple de liste triée.](./figs/sorted_list_example.svg)
. . .
* L'insertion est faite telle que l'ordre est maintenu.
## Quelle structure de données?
```C
```
# Les listes triées
## Quel but?
* Permet de retrouver rapidement un élément.
* Utile pour la recherche de plus court chemin dans des graphes.
* Ordonnancement de processus par degré de priorité.
## Comment?
* Les implémentations les plus efficaces se basent sur les tableaux.
* Possibles aussi avec des listes chaînées.
# Les listes triées
\footnotesize
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
```C
typedef struct _element { // chaque élément
int data;
struct _element *next;
} element;
typedef element* sorted_list; // la liste
```
## Fonctionnalités
```C
// insertion de val
sorted_list sorted_list_push(sorted_list list, int val);
// la liste est-elle vide?
bool is_empty(sorted_list list); // list == NULL
// extraction de val (il disparaît)
sorted_list sorted_list_extract(sorted_list list, int val);
// rechercher un élément et le retourner
element* sorted_list_search(sorted_list list, int val);
```
# L'insertion
## Trois cas
1. La liste est vide.
. . .
![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (sorted_list_is_empty(list)) {
list = malloc(sizeof(*list));
list->data = val;
list->next = NULL;
return list;
}
}
```
# L'insertion
2. L'insertion se fait en première position.
. . .
![Insertion en tête de liste, `list->data >=
val`.](figs/sorted_list_insert_first.svg){width=80%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (list->data >= val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
tmp->next = list;
list = tmp;
return list;
}
}
```
# L'insertion
3. L'insertion se fait sur une autre position que la première.
. . .
![Insertion sur une autre position, list->data <
val.](figs/sorted_list_insert_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_push(sorted_list list, int val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
element *crt = list;
while (NULL != crt->next && val > crt->next->data) {
crt = crt->next;
}
tmp->next = crt->next;
crt->next = tmp;
return list;
}
```
slides/cours_12.md
View file @ febfc3f8
---
title: "Files d'attente, listes triées, et listes doublement chaînées"
date: "2023-12-19"
title: "File d'attente, liste triée, liste doublement chaînée"
date: "2024-12-16"
---
# La file d'attente (1/N)
# La file d'attente
\Huge La file d'attente
# La file d'attente (1/2)
* Structure de données abstraite permettant le stockage d'éléments.
* *FIFO*: First In First Out, ou première entrée première sortie.
* Analogue de la vie "réelle"":
* File à un guichet,
* Serveur d'impressions,
* Mémoire tampon, ...
* File à un guichet,
* Serveur d'impressions,
* Mémoire tampon, ...
## Fonctionnalités
. . .
* Enfiler: ajouter un élément à la fin de la file.
......@@ -24,16 +28,16 @@ date: "2023-12-19"
* Lire l'élément de la fin de la file.
* Lire l'élément du devant de la file.
* Créer une liste vide.
* Détruire une liste.
* Créer une file vide.
* Détruire une file.
# La file d'attente (2/N)
# La file d'attente (2/2)
\footnotesize
## Implémentation possible
* La structure file, contient un pointeur vers la tête et un vers le début de la file.
* La structure de file, contient un pointeur vers la tête et un autre vers le début de la file.
* Entre les deux, les éléments sont stockés dans une liste chaînée.
![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}
......@@ -47,7 +51,7 @@ typedef struct _element { // Elément de liste
int data;
struct _element* next;
} element;
typedef struct _queue { // File d'attente:
typedef struct _queue { // File d'attente
element* head; // tête de file d'attente
element* tail; // queue de file d'attente
} queue;
......@@ -55,7 +59,7 @@ typedef struct _queue { // File d'attente:
# Fonctionnalités d'une file d'attente
## Creation et consultations
## Création et consultations
. . .
......@@ -81,7 +85,7 @@ void queue_destroy(queue *fa);
# Enfilage
## Deux cas différents:
## Deux cas différents
1. La file est vide (faire un dessin):
......@@ -108,16 +112,17 @@ void queue_enqueue(queue *fa, int val) {
elmt->next = NULL;
if (queue_is_empty(*fa)) {
fa->head = elmt;
fa->tail = elmt;
} else {
fa->tail->next = elmt;
fa->tail->next = elmt;
fa->tail = elmt;
}
fa->tail = elmt;
}
```
# Défilage
## Deux cas différents
## Trois cas différents
1. La file a plus d'un élément (faire un dessin):
......@@ -131,7 +136,6 @@ void queue_enqueue(queue *fa, int val) {
![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
3. La file est vide (problème)
# Défilage
......@@ -167,7 +171,7 @@ On défile jusqu'à ce que la file soit vide!
# Complexité
## Quelle sont les complexité de:
## Quelle est la complexité de
* Enfiler?
......@@ -191,8 +195,8 @@ On défile jusqu'à ce que la file soit vide!
* Données stockées dans un tableau;
* Tableau de taille connue à la compilation ou pas (réallouable);
* `tail` seraient les indices du tableau;
* `capacity` seraient la capacité maximale;
* `tail` serait un indice du tableau;
* `capacity` serait la capacité maximale;
* On *enfile* "au bout" du tableau, au défile au début (indice `0`).
. . .
......@@ -230,7 +234,6 @@ typedef struct _queue {
```
* Enfiler?
. . .
......@@ -255,7 +258,7 @@ typedef struct _queue {
# Complexité
## Quelle sont les complexités de:
## Quelle est les complexités de
* Initialisation?
......@@ -276,7 +279,6 @@ typedef struct _queue {
```
* Enfiler?
. . .
......@@ -331,7 +333,7 @@ typedef struct _queue {
```C
void queue_enqueue(queue *fa, int val) {
if ((fa->head == 0 && fa->tail == fa->capacity-1) ||
(fa->tail == fa->head-1)) {
(fa->tail == (fa->head-1) % (fa->capacity-1))) {
return; // queue is full
}
if (fa->head == -1) { // queue was empty
......@@ -344,7 +346,7 @@ void queue_enqueue(queue *fa, int val) {
} else {
// nothing particular
fa->tail += 1;
fa->data[fa->tail] = val;
fa->data[fa->tail] = val;
}
}
```
......@@ -369,6 +371,9 @@ void queue_dequeue(queue *fa, int *val) {
}
```
# Listes triées
\Huge Les listes triées
# Les listes triées
......@@ -412,7 +417,6 @@ Une liste chaînée triée est:
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
```C
......@@ -429,14 +433,14 @@ typedef element* sorted_list; // la liste
// insertion de val
sorted_list sorted_list_push(sorted_list list, int val);
// la liste est-elle vide?
bool is_empty(sorted_list list); // list == NULL
bool sorted_list_is_empty(sorted_list list); // list == NULL
// extraction de val (il disparaît)
sorted_list sorted_list_extract(sorted_list list, int val);
// rechercher un élément et le retourner
element* sorted_list_search(sorted_list list, int val);
```
# L'insertion
# L'insertion (1/3)
## Trois cas
......@@ -459,13 +463,14 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'insertion
# L'insertion (2/3)
2. L'insertion se fait en première position.
. . .
![Insertion en tête de liste, `list->data >= val`.](figs/sorted_list_insert_first.svg){width=80%}
![Insertion en tête de liste, `list->data >=
val`.](figs/sorted_list_insert_first.svg){width=80%}
. . .
......@@ -481,7 +486,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'insertion
# L'insertion (3/3)
3. L'insertion se fait sur une autre position que la première.
......@@ -507,8 +512,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (1/3)
## Trois cas
......@@ -526,9 +530,9 @@ sorted_list sorted_list_push(sorted_list list, int val) {
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
prec = crt;
crt = crt->next;
}
if (NULL != crt && prec != crt && crt->data == val) { // glue things together
prec->next = crt->next;
free(crt);
......@@ -537,8 +541,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (2/3)
2. L'élément à extraire est le premier élément de la liste
......@@ -554,10 +557,11 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && crt->data == val && prec == crt) { // glue things together
prec = crt;
crt = crt->next;
}
// glue things together
if (NULL != crt && crt->data == val && prec == crt) {
list = list->next;
free(crt);
}
......@@ -565,7 +569,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (3/3)
3. L'élément à extraire n'est **pas** dans la liste.
* La liste est vide.
......@@ -584,9 +588,9 @@ On retourne la liste inchangée.
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
prec = crt;
crt = crt->next;
}
if (NULL == crt || crt->data != val) { // val not present
return list;
}
......@@ -595,8 +599,6 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
# La recherche
```C
element* sorted_list_search(sorted_list list, int val);
```
......@@ -612,7 +614,9 @@ element* sorted_list_search(sorted_list list, int val) {
element* pos = sorted_list_position(list, val);
if (NULL == pos && val == list->data) {
return list; // first element contains val
} else if (NULL != pos && NULL != pos->next && val == pos->next->data) {
} else if (NULL != pos && NULL != pos->next
&& val == pos->next->data)
{
return pos->next; // non-first element contains val
} else {
return NULL; // well... val's not here
......@@ -680,14 +684,13 @@ $$
\mathcal{O}(N).
$$
# Liste doublement chaînée
## Application: navigateur ou éditeur de texte
* Avec une liste chaînée:
* Comment implémenter les fonctions `back` et `forward` d'un navigateur?
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
* Comment implémenter les fonctions `back` et `forward` d'un navigateur?
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
. . .
......@@ -707,6 +710,10 @@ Pas possible.
# Liste doublement chaînée
\Huge Liste doublement chaînée
# Liste doublement chaînée
## Exercices
* Partir du dessin suivant et par **groupe de 5**
......@@ -721,7 +728,7 @@ Pas possible.
2. Écrire les fonctionnalités de création et consultation
```C
```C
// crée la liste doublement chaînée
dll dll_create();
// retourne la valeur à la position actuelle dans la liste
......@@ -740,9 +747,9 @@ void dll_print(dll list);
# Liste doublement chaînée
3. Écrire les fonctionnalités de manipulation
3. Écrire les fonctionnalités de manipulation
```C
```C
// déplace pos au début de la liste
dll dll_move_to_head(dll list);
// déplace pos à la position suivante dans la liste
......@@ -773,4 +780,3 @@ int dll_pop(dll *list);
// vide la liste
void dll_destroy(dll *list);
```
slides/cours_13.md
View file @ febfc3f8
---
title: "Listes triées, listes doublement chaînées, et tables de hachage"
date: "2024-01-09"
title: "Liste triée, liste doublement chaînée"
date: "2025-01-06"
---
# Rappel
# Les listes triées
\Huge Listes triées
## Quel but?
# Rappel: liste triées (1/3)
* Permet de retrouver rapidement un élément.
* Utile pour la recherche de plus court chemin dans des graphes.
* Ordonnancement de processus par degré de priorité.
## Qu'est-ce qu'une liste triée?
## Comment?
. . .
* Les implémentations les plus efficaces se basent sur les tableaux.
* Possibles aussi avec des listes chaînées.
* une liste,
* dont les éléments sont insérés dans l'ordre.
# Les listes triées
## Structure de donnée?
\footnotesize
. . .
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
```C
typedef struct _element { // chaque élément
......@@ -28,40 +32,92 @@ typedef struct _element { // chaque élément
typedef element* sorted_list; // la liste
```
# Rappel: liste triées (2/3)
## Fonctionnalités?
. . .
## Fonctionnalités
```C
// insertion de val
sorted_list sorted_list_push(sorted_list list, int val);
// la liste est-elle vide?
bool is_empty(sorted_list list); // list == NULL
bool sorted_list_is_empty(sorted_list list); // list == NULL
// extraction de val (il disparaît)
sorted_list sorted_list_extract(sorted_list list, int val);
// rechercher un élément et le retourner
element* sorted_list_search(sorted_list list, int val);
```
# Rappel: liste triées (3/3)
# L'insertion (1/3)
## L'insertion: 3 cas
## Trois cas
1. La liste est vide.
. . .
2. L'insertion se fait "avant" le premier élément.
![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (sorted_list_is_empty(list)) {
list = malloc(sizeof(*list));
list->data = val;
list->next = NULL;
return list;
}
}
```
# L'insertion (2/3)
2. L'insertion se fait en première position.
. . .
3. L'insertion se fait après la tête de la liste.
![Insertion en tête de liste, `list->data >=
val`.](figs/sorted_list_insert_first.svg){width=80%}
. . .
# L'extraction
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (list->data >= val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
tmp->next = list;
list = tmp;
return list;
}
}
```
# L'insertion (3/3)
3. L'insertion se fait sur une autre position que la première.
. . .
![Insertion sur une autre position, list->data < val.](figs/sorted_list_insert_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_push(sorted_list list, int val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
element *crt = list;
while (NULL != crt->next && val > crt->next->data) {
crt = crt->next;
}
tmp->next = crt->next;
crt->next = tmp;
return list;
}
```
# L'extraction (1/3)
## Trois cas
......@@ -79,9 +135,9 @@ element* sorted_list_search(sorted_list list, int val);
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
prec = crt;
crt = crt->next;
}
if (NULL != crt && prec != crt && crt->data == val) { // glue things together
prec->next = crt->next;
free(crt);
......@@ -90,8 +146,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (2/3)
2. L'élément à extraire est le premier élément de la liste
......@@ -107,9 +162,9 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
prec = crt;
crt = crt->next;
}
// glue things together
if (NULL != crt && crt->data == val && prec == crt) {
list = list->next;
......@@ -119,7 +174,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (3/3)
3. L'élément à extraire n'est **pas** dans la liste.
* La liste est vide.
......@@ -138,9 +193,9 @@ On retourne la liste inchangée.
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
prec = crt;
crt = crt->next;
}
if (NULL == crt || crt->data != val) { // val not present
return list;
}
......@@ -149,8 +204,6 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
# La recherche
```C
element* sorted_list_search(sorted_list list, int val);
```
......@@ -236,14 +289,13 @@ $$
\mathcal{O}(N).
$$
# Liste doublement chaînée
## Application: navigateur ou éditeur de texte
* Avec une liste chaînée:
* Comment implémenter les fonctions `back` et `forward` d'un navigateur?
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
* Comment implémenter les fonctions `back` et `forward` d'un navigateur?
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
. . .
......@@ -281,7 +333,7 @@ Pas possible.
2. Écrire les fonctionnalités de création et consultation
```C
```C
// crée la liste doublement chaînée
dll dll_create();
// retourne la valeur à la position actuelle dans la liste
......@@ -300,9 +352,9 @@ void dll_print(dll list);
# Liste doublement chaînée
3. Écrire les fonctionnalités de manipulation
3. Écrire les fonctionnalités de manipulation
```C
```C
// déplace pos au début de la liste
dll dll_move_to_head(dll list);
// déplace pos à la position suivante dans la liste
......@@ -334,607 +386,3 @@ int dll_pop(dll *list);
void dll_destroy(dll *list);
```
# Les tables de hachage
\Huge Les tables de hachage
# Tableau vs Table
## Tableau
* Chaque élément (ou valeur) est lié à un indice (la case du tableau).
```C
annuaire tab[2] = {
"+41 22 123 45 67", "+41 22 234 56 78", ...
};
tab[1] == "+41 22 123 45 67";
```
## Table
* Chaque élément (ou valeur) est lié à une clé.
```C
annuaire tab = {
// Clé , Valeur
"Paul", "+41 22 123 45 67",
"Orestis", "+41 22 234 56 78",
};
tab["Paul"] == "+41 22 123 45 67";
tab["Orestis"] == "+41 22 234 56 78";
```
# Table
## Définition
Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou
argument).
On parle de paires *clé-valeur* (*key-value pairs*).
## Donnez des exemples de telles paires
. . .
* Annuaire (nom-téléphone),
* Catalogue (objet-prix),
* Table de valeur fonctions (nombre-nombre),
* Index (nombre-page)
* ...
# Table
## Opérations principales sur les tables
* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`
* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`
* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`
## Structure de données / implémentation
Efficacité dépend de différents paramètres:
* taille (nombre de clé-valeurs maximal),
* fréquence d'utilisation (insertion, consultation, suppression),
* données triées/non-triées,
* ...
# Consultation séquentielle (`sequential_get`)
## Séquentielle
* table représentée par un (petit) tableau ou liste chaînée,
* types: `key_t` et `value_t` quelconques, et `key_value_t`
```C
typedef struct {
key_t key;
value_t value;
} key_value_t;
```
* on recherche l'existence de la clé séquentiellement dans le tableau, on
retourne la valeur.
# Consultation séquentielle (`sequential_get`)
## Implémentation? Une idée?
. . .
```C
bool sequential_get(int n, key_value_t table[n], key_t key,
value_t *value)
{
int pos = n - 1;
while (pos >= 0) {
if (key == table[pos].key) {
*value = table[pos].value;
return true;
}
pos--;
}
return false;
}
```
. . .
## Inconvénient?
# Consultation séquentielle (`sequential_get`)
## Exercice: implémenter la même fonction avec une liste chaînée
Poster le résultat sur matrix.
# Consultation dichotomique (`binary_get`)
## Dichotomique
* table représentée par un (petit) tableau trié par les clés,
* types: `key_t` et `value_t` quelconques, et `key_value_t`
* on recherche l'existence de la clé par dichotomie dans le tableau, on
retourne la valeur,
* les clés possèdent la notion d'ordre (`<, >, =` sont définis).
# Consultation dichotomique (`binary_get`)
\footnotesize
## Implémentation? Une idée?
. . .
```C
bool binary_get1(int n, value_key_t table[n], key_t key, value_t *value) {
int top = n - 1, bottom = 0;
while (top > bottom) {
int middle = (top + bottom) / 2;
if (key > table[middle].key) {
bottom = middle+1;
} else {
top = middle;
}
}
if (key == table[top].key) {
*value = table[top].value;
return true;
} else {
return false;
}
}
```
# Consultation dichotomique (`binary_get`)
\footnotesize
## Autre implémentation
```C
bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
int top = n - 1, bottom = 0;
while (true) {
int middle = (top + bottom) / 2;
if (key > table[middle].key) {
bottom = middle + 1;
} else if (key < table[middle].key) {
top = middle;
} else {
*value = table[middle].value;
return true;
}
if (top < bottom) {
break;
}
}
return false;
}
```
## Quelle est la différence avec le code précédent?
# Transformation de clé (hashing)
## Problématique: Numéro AVS (13 chiffres)
* Format: 106.3123.8492.13
```
Numéro AVS | Nom
0000000000000 | -------
... | ...
1063123849213 | Paul
... | ...
3066713878328 | Orestis
... | ...
9999999999999 | -------
```
## Quelle est la clé? Quelle est la valeur?
. . .
* Clé: Numéro AVS, Valeur: Nom.
## Nombre de clés? Nombre de citoyens? Rapport?
. . .
* $10^{13}$ clés, $10^7$ citoyens, $10^{-5}$ ($10^{-3}\%$ de la table est
occupée) $\Rightarrow$ *inefficace*.
* Pire: $10^{13}$ entrées ne rentre pas dans la mémoire d'un
ordinateur.
# Transformation de clé (hashing)
## Problématique 2: Identificateurs d'un programme
* Format: 8 caractères (simplification)
```
Identificateur | Adresse
aaaaaaaa | -------
... | ...
resultat | 3aeff
compteur | 4fedc
... | ...
zzzzzzzz | -------
```
## Quelle est la clé? Quelle est la valeur?
. . .
* Clé: Identificateur, Valeur: Adresse.
## Nombre de clés? Nombre d'identificateur d'un programme? Rapport?
. . .
* $26^{8}\sim 2\cdot 10^{11}$ clés, $2000$ identificateurs, $10^{-8}$ ($10^{-6}\%$ de la table est
occupée) $\Rightarrow$ *un peu inefficace*.
# Fonctions de transformation de clé (hash functions)
* La table est représentée avec un tableau.
* La taille du tableau est beaucoup plus petit que le nombre de clés.
* On produit un indice du tableau à partir d'une clé:
$$
h(key) = n,\quad n\in\mathbb{N}.
$$
En français: on transforme `key` en nombre entier qui sera l'indice dans le
tableau correspondant à `key`.
## La fonction de hash
* La taille du domaine des clés est beaucoup plus grand que le domaine des
indices.
* Plusieurs indices peuvent correspondre à la **même clé**:
* Il faut traiter les **collisions**.
* L'ensemble des indices doit être plus petit ou égal à la taille de la table.
## Une bonne fonction de hash
* Distribue uniformément les clés sur l'ensemble des indices.
# Fonctions de transformation de clés: exemples
## Méthode par troncature
\begin{align*}
&h: [0,9999]\rightarrow [0,9]\\
&h(key)=\mbox{troisième chiffre du nombre.}
\end{align*}
```
Key | Index
0003 | 0
1123 | 2 \
1234 | 3 |-> collision.
1224 | 2 /
1264 | 6
```
## Quelle est la taille de la table?
. . .
C'est bien dix oui.
# Fonctions de transformation de clés: exemples
## Méthode par découpage
Taille de l'index: 3 chiffres.
```
key = 321 991 24 -> 321
991
+ 24
----
1336 -> index = 336
```
## Devinez l'algorithme?
. . .
On part de la gauche:
1. On découpe la clé en tranche de longueur égale à celle de l'index.
2. On somme les nombres obtenus.
3. On tronque à la longueur de l'index.
# Fonctions de transformation de clés: exemples
## Méthode multiplicative
Taille de l'index: 2 chiffres.
```
key = 5486 -> key^2 = 30096196 -> index = 96
```
On prend le carré de la clé et on garde les chiffres du milieu du résultat.
# Fonctions de transformation de clés: exemples
## Méthode par division modulo
Taille de l'index: `N` chiffres.
```
h(key) = key % N.
```
## Quelle doit être la taille de la table?
. . .
Oui comme vous le pensiez au moins `N`.
# Traitement des collisions
## La collision
```
key1 != key2, h(key1) == h(key2)
```
## Traitement (une idée?)
. . .
* La première clé occupe la place prévue dans le tableau.
* La deuxième (troisième, etc.) est placée ailleurs de façon **déterministe**.
Dans ce qui suit la taille de la table est `table_size`.
# La méthode séquentielle
\footnotesize
## Comment ça marche?
* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en
trouver une libre.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + 1) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Problème?
. . .
* Regroupement d'éléments (clustering).
# Méthode linéaire
\footnotesize
## Comment ça marche?
* Comme la méthode séquentielle mais on "saute" de `k`.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + k) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Quelle valeur de `k` éviter?
. . .
* Une valeur où `table_size` est multiple de `k`.
Cette méthode répartit mieux les regroupements au travers de la table.
# Méthode du double hashing
\footnotesize
## Comment ça marche?
* Comme la méthode linéaire, mais `k = h2(key)` (variable).
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + h2(k)) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Quelle propriété doit avoir `h2`?
## Exemple
```C
h2(key) = (table_size - 2) - key % (table_size -2)
```
# Méthode pseudo-aléatoire
\footnotesize
## Comment ça marche?
* Comme la méthode linéaire mais on génère `k` pseudo-aléatoirement.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + random_number) % table_size;
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Comment s'assurer qu'on va bien retrouver la bonne clé?
. . .
* Le germe (seed) de la séquence pseudo-aléatoire doit être le même.
* Le germe à choisir est l'index retourné par `h(key)`.
```C
srand(h(key));
while {
random_number = rand();
}
```
# Méthode quadratique
* La fonction des indices de collision est de degré 2.
* Soit $J_0=h(key)$, les indices de collision se construisent comme:
```C
J_i = J_0 + i^2 % table_size, i > 0,
J_0 = 100, J_1 = 101, J_2 = 104, J_3 = 109, ...
```
## Problème possible?
. . .
* Calculer le carré peut-être "lent".
* En fait on peut ruser un peu.
# Méthode quadratique
\footnotesize
```C
J_i = J_0 + i^2 % table_size, i > 0,
J_0 = 100
\
d_0 = 1
/ \
J_1 = 101 Delta = 2
\ /
d_1 = 3
/ \
J_2 = 104 Delta = 2
\ /
d_2 = 5
/ \
J_3 = 109 Delta = 2
\ /
d_3 = 7
/
J_4 = 116
--------------------------------------
J_{i+1} = J_i + d_i,
d_{i+1} = d_i + Delta, d_0 = 1, i > 0.
```
# Méthode de chaînage
## Comment ça marche?
* Chaque index de la table contient un pointeur vers une liste chaînée
contenant les paires clés-valeurs.
## Un petit dessin
```
```
# Méthode de chaînage
## Exemple
On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre
de l'alphabet)
```
U | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E
10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5
```
## Comment on représente ça? (à vous)
. . .
![La méthode de chaînage](figs/fig_hash.png){width=80%}
# Méthode de chaînage
Avantages:
* Si les clés sont grandes l'économie de place est importante (les places vides
sont `NULL`).
* La gestion des collisions est conceptuellement simple.
* Pas de problème de regroupement (clustering).
# Exercice 1
* Construire une table à partir de la liste de clés suivante:
```
R, E, C, O, U, P, A, N, T
```
* On suppose que la table est initialement vide, de taille $n = 13$.
* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
# Exercice 2
* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
les collisions avec
\begin{align*}
h_1(k)&=k\mod 13,\\
h_2(k)&=1+(k\mod 11).
\end{align*}
* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
collision.
# Exercice 3
* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
tableau de 10 positions.
* Les numéros sont compris entre 100 et 299.
* Soit $N$ le numéro de téléphone, la fonction de hachage est
$$
h(N)=N\mod 10.
$$
* La fonction de gestion des collisions est
$$
C_1(N,i)=(h(N)+3\cdot i)\mod 10.
$$
* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
* Rechercher 35.
* Les cases ni supprimées, ni occupées sont vides.
* Expliquer se qui se passe si on utilise?
$$
C_1(N,i)=(h(N)+5\cdot i)\mod 10.
$$
slides/cours_14.md
View file @ febfc3f8
---
title: "Tables de hachage"
date: "2024-02-20"
date: "2025-02-21"
---
# Les tables de hachage
......@@ -187,6 +187,8 @@ bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
# Transformation de clé (hashing)
\footnotesize
## Problématique: Numéro AVS (13 chiffres)
* Format: 106.3123.8492.13
......@@ -572,3 +574,37 @@ Avantages:
* On suppose que la table est initialement vide, de taille $n = 13$.
* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
# Exercice 2
* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
les collisions avec
\begin{align*}
h_1(k)&=k\mod 13,\\
h_2(k)&=1+(k\mod 11).
\end{align*}
* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
collision.
# Exercice 3
* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
tableau de 10 positions.
* Les numéros sont compris entre 100 et 299.
* Soit $N$ le numéro de téléphone, la fonction de hachage est
$$
h(N)=N\mod 10.
$$
* La fonction de gestion des collisions est
$$
C_1(N,i)=(h(N)+3\cdot i)\mod 10.
$$
* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
* Rechercher 35.
* Les cases ni supprimées, ni occupées sont vides.
* Expliquer se qui se passe si on utilise?
$$
C_1(N,i)=(h(N)+5\cdot i)\mod 10.
$$
slides/cours_15.md
View file @ febfc3f8
---
title: "Fin des tables de hachages et arbres"
date: "2024-02-27"
date: "2025-02-28"
---
# Rappel
......@@ -14,7 +14,7 @@ date: "2024-02-27"
. . .
* Insetion, consultation, suppression.
* Insertion, consultation, suppression.
```C
void insert(table, key, value)
......@@ -37,13 +37,12 @@ date: "2024-02-27"
h_1(k)&=k\mod 13,\\
h_2(k)&=1+(k\mod 11).
\end{align*}
* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
collision.
* En cas de collision, on fait un saut de $h_2(k)$, c.-à-d. $$index = (index + h_2(k)) \mod 13.$$
# Exercice 3
* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
* Stocker les numéros de téléphones internes d'une entreprise dans un
tableau de 10 positions.
* Les numéros sont compris entre 100 et 299.
* Soit $N$ le numéro de téléphone, la fonction de hachage est
......@@ -52,8 +51,9 @@ h(N)=N\mod 10.
$$
* La fonction de gestion des collisions est
$$
C_1(N,i)=(h(N)+3\cdot i)\mod 10.
C_1(N,i)=(h(N)+3\cdot i)\mod 10
$$
où $i$ compte les collisions.
* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
* Rechercher 35.
......@@ -67,7 +67,7 @@ $$
\small
* On considère pas le cas du chaînage en cas de collisions.
* Ici, on ne considère pas le cas du chaînage en cas de collisions.
* L'insertion est construite avec une forme du type
```C
......@@ -97,7 +97,8 @@ $$
rien insertion(table, clé, valeur) {
index = hash(clé)
index =
tant que état(table[index]) == occupé et clé(table[index]) != clé:
tant que état(table[index]) == occupé
et clé(table[index]) != clé:
index = rehash(clé)
état(table[index]) = occupé
......@@ -115,7 +116,8 @@ rien insertion(table, clé, valeur) {
valeur suppression(table, clé):
index = hash(clé)
tant que état(table[index]) != vide:
si état(table[index]) == occupé et clé(table[index]) == clé:
si état(table[index]) == occupé
et clé(table[index]) == clé:
état(table[index]) = supprimé
sinon
index = rehash(clé)
......@@ -132,7 +134,8 @@ valeur suppression(table, clé):
booléen recherche(table, clé) {
index = hash(clé)
tant que état(table[index]) != vide:
si état(table[index]) == occupé et clé(table[index]) == clé:
si état(table[index]) == occupé
et clé(table[index]) == clé:
retourner vrai
sinon
index = rehash
......@@ -212,7 +215,7 @@ void hm_print(hm h);
# Les arbres
{\Huge Les arbres}
\Huge Les arbres
# Les arbres: définition
......@@ -224,15 +227,15 @@ void hm_print(hm h);
## Plus sérieusement
* Ensemble de **nœuds** et d'**arêtes** (graphe),
* Ensemble de **nœuds** et d'**arêtes** (graphe).
* Les arêtes relient les nœuds entre eux, mais pas n'importe comment: chaque
nœud a au plus un **parent**,
* Le seul nœud sans parent est la **racine**,
* Chaque nœud a un nombre fini d'**enfants**,
nœud a au plus un **parent**.
* Le seul nœud sans parent est la **racine**.
* Chaque nœud a un nombre fini d'**enfants**.
* La hiérarchie des nœuds rend les arêtes **orientées** (parent -> enfants), et empêche les
**cycles** (acyclique, orienté).
* La **feuille** ou **nœud terminal** est un nœud sans enfants,
* Le **niveau** est 1 à la racine et **niveau+1** pour les enfants,
* La **feuille** ou **nœud terminal** est un nœud sans enfants.
* Le **niveau** est 1 à la racine et **niveau+1** pour les enfants.
* Le **degré** d'un nœud est le nombre de enfants du nœud.
. . .
......@@ -360,11 +363,11 @@ graph TD;
:::
* Les nœuds de degré 0, sont des feuilles.
* Les nœuds de degré 0 sont des feuilles.
# Application: recherche rapide
## Pouvez vous construire un arbre pour résoudre le nombre secret?
## Pouvez-vous construire un arbre pour résoudre le nombre secret?
. . .
......@@ -396,7 +399,7 @@ graph LR;
:::
# Autres représentation
# Autres représentations
* Botanique
* **Exercice:** Ajouter les degrés/niveaux et feuilles
......@@ -415,7 +418,7 @@ graph TD;
H-->K;
```
# Autres représentation
# Autres représentations
* Ensembliste
......@@ -445,7 +448,7 @@ graph TD;
:::
# Autres représentation
# Autres représentations
* Liste
......@@ -536,605 +539,3 @@ A
:::
# L'arbre binaire
* Structure de données abstraite,
* Chaque nœud a au plus deux enfants: gauche et droite,
* Chaque enfants est un arbre.
## Comment représenteriez vous une telle structure?
. . .
```C
<R, G, D>
R: racine
G: sous-arbre gauche
D: sous-arbre droite
```
## Comment cela s'écrirait en C?
. . .
```C
typedef struct _node {
contenu info;
struct _node *left, *right;
} node;
typedef node *tree;
```
# L'arbre binaire
## Que se passerait-il avec
```C
typedef struct _node {
int info;
struct _node left, right;
} node;
```
* On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!
## Interface minimale
* Qu'y mettriez vous?
. . .
```C
NULL -> arbre (vide)
<n, arbre, arbre> -> arbre
visiter(arbre) -> nœud (la racine de l'arbre)
gauche(arbre) -> arbre (sous-arbre de gauche)
droite(arbre) -> arbre (sous-arbre de droite)
```
* Les autres opérations (insertion, parcours, etc) dépendent de ce qu'on stocke
dans l'arbre.
# Exemple d'arbre binaire
* Représentez `(c - a * b) * (d + e / f)` à l'aide d'un arbre binaire (matrix)
. . .
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
## Remarques
* L'arbre est **hétérogène**: le genre d'info est pas le même sur chaque nœud
(opérateur, opérande).
* Les feuilles contiennent les opérandes.
* Les nœuds internes contiennent les opérateurs.
::::
:::
# Parcours d'arbres binaires
* Appliquer une opération à tous les nœuds de l'arbre,
* Nécessité de **parcourir** l'arbre,
* Utiliser uniquement l'interface: visiter, gauche,
droite.
## Une idée de comment parcourir cet arbre?
* 3 parcours (R: Racine, G: sous-arbre gauche, D: sous-arbre droit):
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
1. Parcours **préfixe** (R, G, D),
2. Parcours **infixe** (G, R, D),
3. Parcours **postfixe** (G, D, R).
::::
:::
# Le parcours infixe (G, R, D)
* Gauche, Racine, Droite:
1. On descend dans l'arbre de gauche tant qu'il est pas vide,
2. On visite la racine du sous arbre,
3. On descend dans le sous-arbre de droite (s'il est pas vide),
4. On recommence.
. . .
## Incompréhensible?
* La récursivité c'est la vie.
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
# Graphiquement (dessinons)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
::::
:::
# Graphiquement (`mermaid` c'est super)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
A[*]-.->|1|B[-];
B-->C[c];
B-.->|2|C[c];
C-.->|3|B;
B-->D[*];
B-.->|4|D;
D-->E[a];
D-.->|5|E;
E-.->|6|D;
D-->F[b];
D-.->|7|F;
F-.->|8|A;
A-->G[+];
A-.->|9|G;
G-->H[d];
G-.->|10|H;
H-.->|11|G;
G-->I["/"];
G-.->|12|I;
I-->J[e];
I-.->|13|J;
J-.->|14|I;
I-->K[f];
I-.->|15|K;
```
::::
:::: column
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
## Remarque
Le nœud est visité à la **remontée**.
## Résultat
```
c - a * b * d + e / f
```
::::
:::
# Et en C?
## Live code
\footnotesize
. . .
```C
typedef int data;
typedef struct _node {
data info;
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
void tree_print(tree_t tree, int n) {
if (NULL != tree) {
tree_print(tree->left, n+1);
for (int i = 0; i < n; i++) {
printf(" ");
}
printf("%d\n", tree->info);
tree_print(tree->right, n+1);
}
}
```
# Question
## Avez-vous compris le fonctionnement?
. . .
## Vous en êtes sûr·e·s?
. . .
## OK, alors deux exercices:
1. Écrire le pseudo-code pour le parcours R, G, D (matrix).
2. Écrire le pseudo-code pour la parcours G, D, R (matrix),
## Rappel
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
# Correction
\footnotesize
* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme
infixe.
## Le parcours postfixe
```python
parcours_postfixe(arbre a)
si est_pas_vide(gauche(a))
parcours_postfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_postfixe(droite(a))
visiter(a)
```
## Le parcours préfixe
```python
parcours_préfixe(arbre a)
visiter(a)
si est_pas_vide(gauche(a))
parcours_préfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_préfixe(droite(a))
```
. . .
**Attention:** L'implémentation de ces fonctions en C sont **à faire** en
exercice (inspirez vous de ce qu'on a fait avant)!
# Exercice: parcours
## Comment imprimer l'arbre ci-dessous?
```
f
/
e
+
d
*
c
-
b
*
a
```
. . .
## Bravo vous avez trouvé!
* Il s'agissait du parcours D, R, G.
# Implémentation
## Vous avez 5 min pour implémenter cette fonction et la poster sur matrix!
. . .
```C
void pretty_print(tree_t tree, int n) {
if (NULL != tree) {
pretty_print(tree->right, n+1);
for (int i = 0; i < n; ++i) {
printf(" ");
}
printf("%d\n", tree->info);
pretty_print(tree->left, n+1);
}
}
```
# Exercice supplémentaire (sans corrigé)
Écrire le code de la fonction
```C
int depth(tree_t t);
```
qui retourne la profondeur maximale d'un arbre.
Indice: la profondeur à chaque niveau peut-être calculée à partir du niveau des
sous-arbres de gauche et de droite.
# La recherche dans un arbre binaire
* Les arbres binaires peuvent retrouver une information très rapidement.
* À quelle complexité? À quelle condition?
. . .
## Condition
* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`
entre les éléments).
## Complexité
* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)
. . .
## Exemple: les arbres lexicographiques
* Chaque nœud contient une information de type ordonné, la **clé**,
* Par construction, pour chaque nœud $N$:
* Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
* Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
# Algorithme de recherche
* Retourner le nœud si la clé est trouvée dans l'arbre.
```python
arbre recherche(clé, arbre)
tante_que est_non_vide(arbre)
si clé < clé(arbre)
arbre = gauche(arbre)
sinon si clé > clé(arbre)
arbre = droite(arbre)
sinon
retourne arbre
retourne NULL
```
# Algorithme de recherche, implémentation (live)
\footnotesize
. . .
```C
typedef int key_t;
typedef struct _node {
key_t key;
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
tree_t search(key_t key, tree_t tree) {
tree_t current = tree;
while (NULL != current) {
if (current->key > X) {
current = current->gauche;
} else if (current->key < X){
current = current->droite;
} else {
return current;
}
}
return NULL;
}
```
# Exercice (5-10min)
Écrire le code de la fonction
```C
int tree_size(tree_t tree);
```
qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur
matrix.
Indication: la taille, est 1 + le nombre de nœuds du sous-arbre de gauche
additionné au nombre de nœuds dans le sous-arbre de droite.
. . .
```C
int arbre_size(tree_t tree) {
if (NULL == tree) {
return 0;
} else {
return 1 + tree_size(tree->left)
+ tree_size(tree->right);
}
}
```
# L'insertion dans un arbre binaire
* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
pas construire l'arbre....
## Pour un arbre lexicographique
* Rechercher la position dans l'arbre où insérer.
* Créer un nœud avec la clé et le rattacher à l'arbre.
# Exemple d'insertions
* Clés uniques pour simplifier.
* Insertion de 5, 15, 10, 25, 2, -5, 12, 14, 11.
* Rappel:
* Plus petit que la clé courante => gauche,
* Plus grand que la clé courante => droite.
* Faisons le dessins ensemble
```
```
## Exercice (3min, puis matrix)
* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5
# Pseudo-code d'insertion (1/2)
* Deux parties:
* Recherche le parent où se passe l'insertion.
* Ajout de l'enfant dans l'arbre.
## Recherche du parent
```
arbre position(arbre, clé)
si est_non_vide(arbre)
si clé < clé(arbre)
suivant = gauche(arbre)
sinon
suivant = droite(arbre)
tant que clé(arbre) != clé && est_non_vide(suivant)
arbre = suivant
si clé < clé(arbre)
suivant = gauche(arbre)
sinon
suivant = droite(arbre)
retourne arbre
```
# Pseudo-code d'insertion (2/2)
* Deux parties:
* Recherche de la position.
* Ajout dans l'arbre.
## Ajout de l'enfant
```
ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
sinon
si clé < clé(arbre)
gauche(arbre) = nœud(clé)
sinon si clé > clé(arbre)
droite(arbre) = nœud(clé)
sinon
retourne
```
# Code d'insertion en C
## Recherche du parent (ensemble)
. . .
```C
tree_t position(tree_t tree, key_t key) {
tree_t current = tree;
if (NULL != current) {
tree_t subtree = key > current->key ? current->right :
current->left;
while (key != current->key && NULL != subtree) {
current = subtree;
subtree = key > current->key ? current->right :
current->left;
}
}
return current;
}
```
[^2]: Copyright cours de mathématiques pendant trop d'années.
slides/cours_16.md
View file @ febfc3f8
---
title: "Arbres"
date: "2024-03-05"
title: "Arbres binaires"
date: "2025-03-07"
---
# Les arbres
# Les arbres binaires
{\Huge Les arbres}
# Les arbres: définition
"Un arbre est un graphe acyclique orienté possédant une unique racine, et tel que tous les nœuds sauf la racine ont un unique parent."
. . .
**Santé!**
## Plus sérieusement
* Ensemble de **nœuds** et d'**arêtes** (graphe),
* Les arêtes relient les nœuds entre eux, mais pas n'importe comment: chaque
nœud a au plus un **parent**,
* Le seul nœud sans parent est la **racine**,
* Chaque nœud a un nombre fini d'**enfants**,
* La hiérarchie des nœuds rend les arêtes **orientées** (parent -> enfants), et empêche les
**cycles** (acyclique, orienté).
* La **feuille** ou **nœud terminal** est un nœud sans enfants,
* Le **niveau** est 1 à la racine et **niveau+1** pour les enfants,
* Le **degré** d'un nœud est le nombre de enfants du nœud.
. . .
* Chaque nœud est un arbre en lui même.
* La **récursivité** sera très utile!
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->2;
3-->4;
3-->5;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
```
::::
:::
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
6-->7;
7-->3;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph TD;
1;
```
::::
:::
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1---2;
1---3;
3---4;
3---5;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph BT;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
```
::::
:::
# Degré et niveau
* Illustration du degré (nombre d'enfants) et du niveau (profondeur)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1[degré 2]-->2[degré 0];
1-->3[degré 3];
3-->4[degré 0];
3-->5[degré 0];
3-->6[degré 0];
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph TD;
1[niveau 1]-->2[niveau 2];
1-->3[niveau 2];
3-->4[niveau 3];
3-->5[niveau 3];
3-->6[niveau 3];
```
::::
:::
* Les nœuds de degré 0, sont des feuilles.
# Application: recherche rapide
## Pouvez vous construire un arbre pour résoudre le nombre secret?
. . .
* Le nombre secret ou la recherche dichotomique (nombre entre 0 et 10).
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
5-->|<|2;
5-->|>|7;
7-->|>|8;
7-->|<|6;
8-->|>|9;
9-->|>|10;
2-->|<|1;
2-->|>|3;
3-->|>|4;
1-->|<|0;
```
::::
:::: column
**Question:** Quelle est la complexité pour trouver un nombre?
::::
:::
# Autres représentation
* Botanique
* **Exercice:** Ajouter les degrés/niveaux et feuilles
```{.mermaid width=250 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
# Autres représentation
* Ensembliste
::: columns
:::: column
```{.mermaid width=300 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
![](figs/ensemble.svg)
::::
:::
# Autres représentation
* Liste
::: columns
:::: column
```{.mermaid width=400 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
```
(A
(B
(D)
(E)
(F
(I)
(J)
)
)
(C
(G)
(H
(K)
)
)
)
```
::::
:::
# Autres représentation
* Par niveau
::: columns
:::: column
```{.mermaid width=400 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
```
1 2 3 4
-------------------------
A
B
D
E
F
I
J
C
G
H
K
```
::::
:::
\Huge Les arbres binaires
# L'arbre binaire
* Structure de données abstraite,
* Chaque nœud a au plus deux enfants: gauche et droite,
* Chaque enfants est un arbre.
* Chaque enfant est un arbre.
## Comment représenteriez vous une telle structure?
......@@ -355,11 +33,12 @@ typedef struct _node {
contenu info;
struct _node *left, *right;
} node;
typedef node *tree;
```
# L'arbre binaire
\footnotesize
## Que se passerait-il avec
```C
......@@ -369,6 +48,8 @@ typedef struct _node {
} node;
```
. . .
* On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!
## Interface minimale
......@@ -417,7 +98,7 @@ graph TD;
## Remarques
* L'arbre est **hétérogène**: le genre d'info est pas le même sur chaque nœud
* L'arbre est **hétérogène**: le genre d'info n'est pas le même sur chaque nœud
(opérateur, opérande).
* Les feuilles contiennent les opérandes.
* Les nœuds internes contiennent les opérateurs.
......@@ -469,24 +150,24 @@ graph TD;
# Le parcours infixe (G, R, D)
* Gauche, Racine, Droite:
1. On descend dans l'arbre de gauche tant qu'il est pas vide,
2. On visite la racine du sous arbre,
3. On descend dans le sous-arbre de droite (s'il est pas vide),
1. On descend dans l'arbre de gauche tant qu'il n'est pas vide.
2. On visite la racine du sous arbre.
3. On descend dans le sous-arbre de droite (s'il n'est pas vide).
4. On recommence.
. . .
## Incompréhensible?
* La récursivité c'est la vie.
* La récursivité, c'est la vie.
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(a)
si est_pas_vide(droite(a))
parcours_infixe(droite(a))
```
# Graphiquement (dessinons)
......@@ -513,11 +194,11 @@ graph TD;
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(a)
si est_pas_vide(droite(a))
parcours_infixe(droite(a))
```
::::
......@@ -564,11 +245,11 @@ graph TD;
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(a)
si est_pas_vide(droite(a))
parcours_infixe(droite(a))
```
## Remarque
......@@ -600,8 +281,7 @@ typedef struct _node {
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
void tree_print(tree_t tree, int n) {
void tree_print(node *tree, int n) {
if (NULL != tree) {
tree_print(tree->left, n+1);
for (int i = 0; i < n; i++) {
......@@ -626,7 +306,7 @@ void tree_print(tree_t tree, int n) {
## OK, alors deux exercices:
1. Écrire le pseudo-code pour le parcours R, G, D (matrix).
2. Écrire le pseudo-code pour la parcours G, D, R (matrix),
2. Écrire le pseudo-code pour la parcours G, D, R (matrix).
## Rappel
......@@ -643,7 +323,7 @@ parcours_infixe(arbre a)
\footnotesize
* Les deux parcours sont des modifications **triviales**[^2] de l'algorithme
* Les deux parcours sont des modifications **triviales** de l'algorithme
infixe.
## Le parcours postfixe
......@@ -704,7 +384,7 @@ exercice (inspirez vous de ce qu'on a fait avant)!
. . .
```C
void pretty_print(tree_t tree, int n) {
void pretty_print(node *tree, int n) {
if (NULL != tree) {
pretty_print(tree->right, n+1);
for (int i = 0; i < n; ++i) {
......@@ -721,7 +401,7 @@ void pretty_print(tree_t tree, int n) {
Écrire le code de la fonction
```C
int depth(tree_t t);
int depth(node *t);
```
qui retourne la profondeur maximale d'un arbre.
......@@ -749,18 +429,18 @@ sous-arbres de gauche et de droite.
## Exemple: les arbres lexicographiques
* Chaque nœud contient une information de type ordonné, la **clé**,
* Chaque nœud contient une information de type ordonné, la **clé**.
* Par construction, pour chaque nœud $N$:
* Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
* Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
* Toute clé du sous-arbre à gauche de $N$ est inférieure à la clé de $N$.
* Toute clé du sous-arbre à droite de $N$ est inférieure à la clé de $N$.
# Algorithme de recherche
* Retourner le nœud si la clé est trouvée dans l'arbre.
```python
arbre recherche(clé, arbre)
tante_que est_non_vide(arbre)
tree recherche(clé, arbre)
tant_que est_non_vide(arbre)
si clé < clé(arbre)
arbre = gauche(arbre)
sinon si clé > clé(arbre)
......@@ -783,14 +463,13 @@ typedef struct _node {
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
tree_t search(key_t key, tree_t tree) {
tree_t current = tree;
node *search(key_t key, node *tree) {
node *current = tree;
while (NULL != current) {
if (current->key > X) {
current = current->gauche;
} else if (current->key < X){
current = current->droite;
if (current->key > key) {
current = current->left;
} else if (current->key < key){
current = current->right;
} else {
return current;
}
......@@ -804,7 +483,7 @@ tree_t search(key_t key, tree_t tree) {
Écrire le code de la fonction
```C
int tree_size(tree_t tree);
int tree_size(node *tree);
```
qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur
......@@ -816,7 +495,7 @@ additionné au nombre de nœuds dans le sous-arbre de droite.
. . .
```C
int arbre_size(tree_t tree) {
int tree_size(node *tree) {
if (NULL == tree) {
return 0;
} else {
......@@ -828,7 +507,7 @@ int arbre_size(tree_t tree) {
# L'insertion dans un arbre binaire
* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
* C'est bien joli de pouvoir faire des parcours, recherches, mais si on ne peut
pas construire l'arbre....
## Pour un arbre lexicographique
......@@ -861,8 +540,7 @@ int arbre_size(tree_t tree) {
* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5
# Pseudo-code d'insertion (1/2)
# Pseudo-code d'insertion (1/4)
* Deux parties:
* Recherche le parent où se passe l'insertion.
......@@ -871,7 +549,7 @@ int arbre_size(tree_t tree) {
## Recherche du parent
```
arbre position(arbre, clé)
tree position(arbre, clé)
si est_non_vide(arbre)
si clé < clé(arbre)
suivant = gauche(arbre)
......@@ -887,7 +565,7 @@ arbre position(arbre, clé)
retourne arbre
```
# Pseudo-code d'insertion (2/2)
# Pseudo-code d'insertion (2/4)
* Deux parties:
* Recherche de la position.
......@@ -896,7 +574,7 @@ arbre position(arbre, clé)
## Ajout de l'enfant
```
ajout(arbre, clé)
rien ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
sinon
......@@ -915,19 +593,301 @@ ajout(arbre, clé)
. . .
```C
tree_t position(tree_t tree, key_t key) {
tree_t current = tree;
node *position(node *tree, key_t key) {
node * current = tree;
if (NULL != current) {
tree_t subtree = key > current->key ? current->right :
current->left;
node *subtree = key > current->key
? current->right : current->left;
while (key != current->key && NULL != subtree) {
current = subtree;
subtree = key > current->key ? current->right :
current->left;
subtree = key > current->key
? current->right : current->left;
}
}
return current;
}
```
[^2]: Copyright cours de mathématiques pendant trop d'années.
# L'insertion (3/4)
* Deux parties:
* Recherche de la position.
* Ajout dans l'arbre.
## Ajout du fils (pseudo-code)
```
rien ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
sinon
arbre = position(arbre, clé)
si clé < clé(arbre)
gauche(arbre) = nœud(clé)
sinon si clé > clé(arbre)
droite(arbre) = nœud(clé)
sinon
retourne
```
# L'insertion (4/4)
## Ajout du fils (code)
\scriptsize
* 2 cas: arbre vide ou pas.
* on retourne un pointeur vers le nœud ajouté (ou `NULL`)
. . .
```C
node *add_key(node **tree, key_t key) {
node *new_node = calloc(1, sizeof(*new_node));
new_node->key = key;
if (NULL == *tree) {
*tree = new_node;
} else {
node * subtree = position(*tree, key);
if (key == subtree->key) {
return NULL;
} else {
if (key > subtree->key) {
subtree->right = new_node;
} else {
subtree->left = new_node;
}
}
}
return new_node;
}
```
# La suppression de clé
::: columns
:::: column
## Cas simples:
* le nœud est absent,
* le nœud est une feuille,
* le nœuds a un seul fils.
## Une feuille (le 19 p.ex.).
```{.mermaid format=pdf width=150 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->21
20-->19
```
::::
:::: column
## Un seul fils (le 20 p.ex.).
```{.mermaid format=pdf width=400 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->25
20-->18
25-->24
25-->30
5-->4;
5-->8;
style 18 fill:#fff,stroke:#fff,color:#fff
```
## Dans tous les cas
* Chercher le nœud à supprimer: utiliser `position()`.
::::
:::
# La suppression de clé
::: columns
:::: column
## Cas compliqué
* Le nœud à supprimer a (au moins) deux descendants (10).
```{.mermaid format=pdf width=400 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->25
20-->18
25-->24
25-->30
5-->4;
5-->8;
```
::::
:::: column
* Si on enlève 10, il se passe quoi?
. . .
* On ne peut pas juste enlever `10` et recoller...
* Proposez une solution !
. . .
## Solution
* Échange de la valeur à droite dans le sous-arbre de gauche ou ...
* de la valeur de gauche dans le sous-arbre de droite!
* Puis, on retire le nœud.
::::
:::
# Le pseudo-code de la suppression
## Pour une feuille ou absent (ensemble)
```
tree suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(sous_arbre) ou clé(sous_arbre) != clé
retourne vide
sinon
si est_feuille(sous_arbre) et clé(sous_arbre) == clé
nouvelle_feuille = parent(arbre, sous_arbre)
si est_vide(nouvelle_feuille)
arbre = vide
sinon
si gauche(nouvelle_feuille) == sous_arbre
gauche(nouvelle_feuille) = vide
sinon
droite(nouvelle_feuille) = vide
retourne sous_arbre
```
# Il nous manque le code pour le `parent`
## Pseudo-code pour trouver le parent (5min -> matrix)
. . .
```
tree parent(arbre, sous_arbre)
si est_non_vide(arbre)
actuel = arbre
parent = actuel
clé = clé(sous_arbre)
faire
si (clé != clé(actuel))
parent = actuel
si clé < clé(actuel)
actuel = gauche(actuel)
sinon
actuel = droite(actuel)
sinon
retour parent
tant_que (actuel != sous_arbre)
retourne vide
```
# Le pseudo-code de la suppression
\footnotesize
## Pour un seul enfant (5min -> matrix)
. . .
```
tree suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(gauche(sous_arbre)) ou est_vide(droite(sous_arbre))
parent = parent(arbre, sous_arbre)
si est_vide(gauche(sous_arbre))
si droite(parent) == sous_arbre
droite(parent) = droite(sous_arbre)
sinon
gauche(parent) = droite(sous_arbre)
sinon
si droite(parent) == sous_arbre
droite(parent) = gauche(sous_arbre)
sinon
gauche(parent) = gauche(sous_arbre)
retourne sous_arbre
```
# Le pseudo-code de la suppression
\footnotesize
## Pour au moins deux enfants (ensemble)
```
tree suppression(arbre, clé)
sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la clé
si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
max_gauche = position(gauche(sous_arbre), clé)
échange(clé(max_gauche), clé(sous_arbre))
suppression(gauche(sous_arbre), clé)
```
# Exercices (poster sur matrix)
1. Écrire le pseudo-code de l'insertion purement en récursif.
. . .
```
tree insertion(arbre, clé)
si est_vide(arbre)
retourne nœud(clé)
si (clé < arbre->clé)
gauche(arbre) = insert(gauche(arbre), clé)
sinon
droite(arbre) = insert(droite(arbre), clé)
retourne arbre
```
# Exercices (poster sur matrix)
2. Écrire le pseudo-code de la recherche purement en récursif.
. . .
```
booléen recherche(arbre, clé)
si est_vide(arbre)
retourne faux // pas trouvée
si clé(arbre) == clé
retourne vrai // trouvée
si clé < clé(arbre)
retourne recherche(gauche(arbre), clé)
sinon
retourne recherche(droite(arbre), clé)
```
# Exercices (à la maison)
3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche
l'arbre.
slides/cours_17.md
View file @ febfc3f8
---
title: "Arbres"
date: "2024-03-12"
title: "Arbres binaires, tri par tas"
date: "2025-03-14"
---
# Rappel: arbre binaire
# Les arbres binaires
## Qu'est-ce qu'un arbre binaire?
\Huge Les arbres binaires
. . .
* Structure de données abstraite,
* Chaque nœud a au plus deux enfants: gauche et droite,
* Chaque enfants est un arbre.
# Rappel: parcous (infixe, GRD)
. . .
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(a)
si est_pas_vide(droite(a))
parcours_infixe(droite(a))
```
# Rappel: parcours (postfixe, GDR)
. . .
```python
parcours_postfixe(arbre a)
si est_pas_vide(gauche(a))
parcours_postfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_postfixe(droite(a))
visiter(a)
```
# Rappel: parcours (préfixe, RGD)
. . .
```python
parcours_préfixe(arbre a)
visiter(a)
si est_pas_vide(gauche(a))
parcours_préfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_préfixe(droite(a))
```
# La recherche dans un arbre binaire
* Les arbres binaires peuvent retrouver une information très rapidement.
* À quelle complexité? À quelle condition?
. . .
## Condition
* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`
entre les éléments).
## Complexité
* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)
. . .
## Exemple: les arbres lexicographiques
* Chaque nœud contient une information de type ordonné, la **clé**,
* Par construction, pour chaque nœud $N$:
* Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
* Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
# Rappel pour l'insertion
# Algorithme de recherche
* Les éléments insérés ont une notion d'ordre
* On parcourt l'arbre jusqu'à pouvoir ajouter une nouvelle feuille
* Retourner le nœud si la clé est trouvée dans l'arbre.
```python
arbre recherche(clé, arbre)
tante_que est_non_vide(arbre)
si clé < clé(arbre)
arbre = gauche(arbre)
sinon si clé > clé(arbre)
arbre = droite(arbre)
sinon
retourne arbre
retourne NULL
```
# Algorithme de recherche, implémentation (live)
# Pseudo-code d'insertion (1/4)
\footnotesize
. . .
```C
typedef int key_t;
typedef struct _node {
key_t key;
struct _node* left;
struct _node* right;
} node;
node * search(key_t key, node * tree) {
node * current = tree;
while (NULL != current) {
if (current->key > X) {
current = current->gauche;
} else if (current->key < X){
current = current->droite;
} else {
return current;
}
}
return NULL;
}
```
# Exercice (5-10min)
Écrire le code de la fonction
```C
int tree_size(node * tree);
```
qui retourne le nombre total de nœuds d'un arbre et poster le résultat sur
matrix.
Indication: la taille, est 1 + le nombre de nœuds du sous-arbre de gauche
additionné au nombre de nœuds dans le sous-arbre de droite.
. . .
```C
int arbre_size(node * tree) {
if (NULL == tree) {
return 0;
} else {
return 1 + tree_size(tree->left)
+ tree_size(tree->right);
}
}
```
# L'insertion dans un arbre binaire
* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
pas construire l'arbre....
## Pour un arbre lexicographique
* Rechercher la position dans l'arbre où insérer.
* Créer un nœud avec la clé et le rattacher à l'arbre.
# Exemple d'insertions
* Clés uniques pour simplifier.
* Insertion de 5, 15, 10, 25, 2, -5, 12, 14, 11.
* Rappel:
* Plus petit que la clé courante => gauche,
* Plus grand que la clé courante => droite.
* Faisons le dessins ensemble
```
```
## Exercice (3min, puis matrix)
* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5
# Pseudo-code d'insertion (1/4)
* Deux parties:
* Recherche le parent où se passe l'insertion.
* Ajout de l'enfant dans l'arbre.
## Recherche du parent
```
arbre position(arbre, clé)
si est_non_vide(arbre)
si clé < clé(arbre)
suivant = gauche(arbre)
```python
arbre position(tree, clé)
si est_non_vide(tree)
si clé < clé(tree)
suivant = gauche(tree)
sinon
suivant = droite(arbre)
tant que clé(arbre) != clé && est_non_vide(suivant)
arbre = suivant
si clé < clé(arbre)
suivant = gauche(arbre)
suivant = droite(tree)
tant que clé(tree) != clé && est_non_vide(suivant)
tree = suivant
si clé < clé(tree)
suivant = gauche(tree)
sinon
suivant = droite(arbre)
suivant = droite(tree)
retourne arbre
retourne tree
```
# Pseudo-code d'insertion (2/4)
......@@ -218,14 +48,14 @@ arbre position(arbre, clé)
## Ajout de l'enfant
```
ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
rien ajout(tree, clé)
si est_vide(tree)
tree = nœud(clé)
sinon
si clé < clé(arbre)
gauche(arbre) = nœud(clé)
sinon si clé > clé(arbre)
droite(arbre) = nœud(clé)
si clé < clé(tree)
gauche(tree) = nœud(clé)
sinon si clé > clé(tree)
droite(tree) = nœud(clé)
sinon
retourne
```
......@@ -237,15 +67,15 @@ ajout(arbre, clé)
. . .
```C
node * position(node * tree, key_t key) {
node *position(node *tree, key_t key) {
node * current = tree;
if (NULL != current) {
node * subtree = key > current->key ? current->right :
current->left;
node *subtree = key > current->key
? current->right : current->left;
while (key != current->key && NULL != subtree) {
current = subtree;
subtree = key > current->key ? current->right :
current->left;
subtree = key > current->key
? current->right : current->left;
}
}
return current;
......@@ -261,15 +91,15 @@ node * position(node * tree, key_t key) {
## Ajout du fils (pseudo-code)
```
rien ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
rien ajout(tree, clé)
si est_vide(tree)
tree = nœud(clé)
sinon
arbre = position(arbre, clé)
si clé < clé(arbre)
gauche(arbre) = nœud(clé)
sinon si clé > clé(arbre)
droite(arbre) = nœud(clé)
tree = position(tree, clé)
si clé < clé(tree)
gauche(tree) = nœud(clé)
sinon si clé > clé(tree)
droite(tree) = nœud(clé)
sinon
retourne
```
......@@ -288,8 +118,8 @@ rien ajout(arbre, clé)
. . .
```C
node * add_key(node **tree, key_t key) {
node_t *new_node = calloc(1, sizeof(*new_node));
node *add_key(node **tree, key_t key) {
node *new_node = calloc(1, sizeof(*new_node));
new_node->key = key;
if (NULL == *tree) {
*tree = new_node;
......@@ -309,8 +139,11 @@ node * add_key(node **tree, key_t key) {
}
```
# La suppression de clé
# La suppression dans un arbre binaire
\Huge La suppression dans un arbre binaire
# La suppression de clé
::: columns
......@@ -319,7 +152,7 @@ node * add_key(node **tree, key_t key) {
## Cas simples:
* le nœud est absent,
* le nœud est une feuille
* le nœud est une feuille,
* le nœuds a un seul fils.
## Une feuille (le 19 p.ex.).
......@@ -328,8 +161,8 @@ node * add_key(node **tree, key_t key) {
flowchart TB;
10-->20;
10-->5
20-->21
20-->19
20-->21
```
::::
......@@ -368,7 +201,7 @@ flowchart TB;
## Cas compliqué
* Le nœud à supprimer à (au moins) deux descendants (10).
* Le nœud à supprimer a (au moins) deux descendants (10).
```{.mermaid format=pdf width=400 loc=figs/}
flowchart TB;
......@@ -386,19 +219,18 @@ flowchart TB;
:::: column
* Si on enlève 10 il se passe quoi?
* Si on enlève 10, il se passe quoi?
. . .
* On peut pas juste enlever `10` et recoller...
* Proposez une solution bon sang!
* On ne peut pas juste enlever `10` et recoller...
* Proposez une solution !
. . .
## Solution
* Échange de la valeur à droite dans le sous-arbre de gauche ou
...
* Échange de la valeur à droite dans le sous-arbre de gauche ou ...
* de la valeur de gauche dans le sous-arbre de droite!
* Puis, on retire le nœud.
......@@ -406,3 +238,1078 @@ flowchart TB;
:::
# Le pseudo-code de la suppression
## Pour une feuille ou absent (ensemble)
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(sous_arbre) ou clé(sous_arbre) != clé
retourne vide
sinon
si est_feuille(sous_arbre) et clé(sous_arbre) == clé
nouvelle_feuille = parent(arbre, sous_arbre)
si est_vide(nouvelle_feuille)
arbre = vide
sinon
si gauche(nouvelle_feuille) == sous_arbre
gauche(nouvelle_feuille) = vide
sinon
droite(nouvelle_feuille) = vide
retourne sous_arbre
```
# 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)
actuel = arbre
parent = actuel
clé = clé(sous_arbre)
faire
si (clé != clé(actuel))
parent = actuel
si clé < clé(actuel)
actuel = gauche(actuel)
sinon
actuel = droite(actuel)
sinon
retour parent
tant_que (actuel != sous_arbre)
retourne vide
```
# Le pseudo-code de la suppression
\footnotesize
## Pour un seul enfant (5min -> matrix)
. . .
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(gauche(sous_arbre)) ou est_vide(droite(sous_arbre))
parent = parent(arbre, sous_arbre)
si est_vide(gauche(sous_arbre))
si droite(parent) == sous_arbre
droite(parent) = droite(sous_arbre)
sinon
gauche(parent) = droite(sous_arbre)
sinon
si droite(parent) == sous_arbre
droite(parent) = gauche(sous_arbre)
sinon
gauche(parent) = gauche(sous_arbre)
retourne sous_arbre
```
# Le pseudo-code de la suppression
\footnotesize
## Pour au moins deux enfants (ensemble)
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la clé
si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
max_gauche = position(gauche(sous_arbre), clé)
échange(clé(max_gauche), clé(sous_arbre))
suppression(gauche(sous_arbre), clé)
```
# Exercices (poster sur matrix)
1. Écrire le pseudo-code de l'insertion purement en récursif.
. . .
```
arbre insert(tree, clé)
si est_vide(tree)
retourne nœud(clé)
si (clé < tree(clé))
gauche(tree) = insert(gauche(tree), clé)
sinon
droite(tree) = insert(droite(tree), clé)
retourne tree
```
# Exercices (poster sur matrix)
2. Écrire le pseudo-code de la recherche purement en récursif.
. . .
```
booléen recherche(tree, clé)
si est_vide(tree)
retourne faux // pas trouvée
si clé(tree) == clé
retourne vrai // trouvée
si clé < clé(tree)
retourne recherche(gauche(tree), clé)
sinon
retourne recherche(droite(tree), clé)
```
# Exercices (à la maison)
3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche l'arbre.
# Le tri par tas
\Huge Le tri par tas
# Trier un tableau à l'aide d'un arbre binaire
* Tableau représenté comme un arbre binaire.
* Aide à comprendre "comment" trier, mais on ne construit jamais l'arbre.
* Complexité $O(N\log_2 N)$ en moyenne et grande stabilité (pas de cas
dégénérés).
# Lien entre arbre et tableau
* La racine de l'arbre est le premier élément du tableau.
* Les deux fils d'un nœud d'indice $i$, ont pour indices $2i+1$ et $2i+2$:
* Les fils du nœud $i=0$ sont en $2\cdot 0+1=1$ et $2\cdot 0+2=2$.
* Les fils du nœud $i=1$ sont en $2\cdot 1+1=3$ et $2\cdot 1+2=4$.
* Les fils du nœud $i=2$ sont en $2\cdot 2+2=5$ et $2\cdot 1+2=6$.
* Les fils du nœud $i=3$ sont en $2\cdot 3+1=7$ et $2\cdot 3+2=8$.
* Un élément d'indice $i$ a pour parent l'élément $(i-1)/2$ (division entière):
* Le parent du nœud $i=8$ est $(8-1)/2=3$.
* Le parent du nœud $i=7$ est $(7-1)/2=3$.
# Visuellement
::: columns
:::: column
* Où vont les indices correspondant du tableau?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0(( ))-->id1(( ));
id0-->id2(( ));
id1-->id3(( ));
id1-->id4(( ));
id2-->id5(( ));
id2-->id6(( ));
id3-->id7(( ));
id3-->id8(( ));
id4-->id9(( ));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
* Les flèches de gauche à droite, parent -> enfants.
* Les flèches de droite à gauche, enfants -> parent.
![Dualité tableau arbre binaire.](figs/heap_tree.svg)
::::
:::
**Propriétés:**
1. les feuilles sont toutes sur l'avant dernier ou dernier niveau.
2. les feuilles de profondeur maximale sont "tassées" à gauche.
# Le tas (ou heap)
## Définition
* Un arbre est un tas, si la valeur de chacun de ses descendants est inférieure
ou égale à sa propre valeur.
## Exemples (ou pas)
```
16 8 14 6 2 10 12 4 5 # Tas
16 14 8 6 2 10 12 4 5 # Non-tas, 10 > 8 et 12 > 8
```
## Exercices (ou pas)
```
19 18 12 12 17 1 13 4 5 # Tas ou pas tas?
19 18 16 12 17 1 12 4 5 # Tas ou pas tas?
```
. . .
```
19 18 12 12 17 1 13 4 5 # Pas tas! 13 > 12
19 18 16 12 17 1 12 4 5 # Tas!
```
# Exemple de tri par tas (1/13)
```
| 1 | 16 | 5 | 12 | 4 | 2 | 8 | 10 | 6 | 7 |
```
::: columns
:::: column
* Quel est l'arbre que cela représente?
. . .
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((4));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((7));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* On commence à l'indice $N/2-1 = 4$: `4`.
* `7 > 4` (enfant `>` parent).
* intervertir `4` et `7`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::
. . .
```
* *
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
# Exemple de tri par tas (2/13)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* On continue à l'indice $N/2-2 = 3$: `12`.
* Déjà un tas, rien à faire.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* On continue à l'indice $N/2-3 = 2$: `5`.
* `5 < 8`, échanger `8` et `5` (aka `max(2, 5, 8)`)
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::
. . .
```
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Exemple de tri par tas (3/13)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-2 = 3$: `12`.
* Déjà un tas, rien à faire.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-3 = 2$: `5`.
* `5 < 8`, `5 <=> max(2, 5, 8)`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::
```
* *
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Exemple de tri par tas (4/13)
```
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-4 = 1$: `16`.
* Déjà un tas, rien à faire.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-5 = 0$: `1`.
* `1 < 16 && 1 < 8`, `1 <=> max(1, 16, 8)`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((1));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::
```
* *
| 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Exemple de tri par tas (5/13)
```
| 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Recommencer avec `1`.
* `1 <=> max(1, 12, 7)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((12));
id0-->id2((8));
id1-->id3((1));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* Recommencer avec `1`.
* `1 <=> max(1, 10, 6)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((12));
id0-->id2((8));
id1-->id3((10));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
::::
:::
```
* * *
| 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
```
* L'arbre est un tas.
# Exemple de tri par tas (6/13)
```
| 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `16` (`max` de l'arbre) avec `4`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((12));
id0-->id2((8));
id1-->id3((10));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((6));
```
::::
:::: column
**But:** Trier les tas.
* `4 <=> max(4, 12, 8)`.
* `4 <=> max(4, 10, 7)`.
* `4 <=> max(4, 1, 6)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((10));
id0-->id2((8));
id1-->id3((6));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((4));
```
::::
:::
```
| 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
```
# Exemple de tri par tas (7/13)
```
| 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `12` (`max` de l'arbre) avec `4`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((10));
id0-->id2((8));
id1-->id3((6));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8(( ));
style id8 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Trier les tas.
* `4 <=> max(4, 10, 8)`.
* `4 <=> max(4, 6, 7)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((10))-->id1((7));
id0-->id2((8));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8(( ));
style id8 fill:#fff,stroke:#fff
```
::::
:::
```
| 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
```
# Exemple de tri par tas (8/13)
```
| 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `10` (`max` de l'arbre) avec `1`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((7));
id0-->id2((8));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((5));
```
::::
:::: column
**But:** Trier les tas.
* `1 <=> max(1, 7, 8)`.
* `5 <=> max(1, 2, 5)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((8))-->id1((7));
id0-->id2((5));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((1));
```
::::
:::
```
| 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
```
# Exemple de tri par tas (9/13)
```
| 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `8` (`max` de l'arbre) avec `1`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((7));
id0-->id2((5));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6(( ));
style id6 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Trier les tas.
* `1 <=> max(1, 7, 5)`.
* `1 <=> max(1, 6, 4)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((7))-->id1((6));
id0-->id2((5));
id1-->id3((1));
id1-->id4((4));
id2-->id5((2));
id2-->id6(( ));
style id6 fill:#fff,stroke:#fff
```
::::
:::
```
| 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
```
# Exemple de tri par tas (10/13)
```
| 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `7` (`max` de l'arbre) avec `2`.
* Traiter la racine.
```{.mermaid format=pdf width=150 loc=figs/}
graph TD;
id0((2))-->id1((6));
id0-->id2((5));
id1-->id3((1));
id1-->id4((4));
```
::::
:::: column
**But:** Trier les tas.
* `2 <=> max(2, 6, 5)`.
* `2 <=> max(2, 1, 4)`.
```{.mermaid format=pdf width=150 loc=figs/}
graph TD;
id0((6))-->id1((4));
id0-->id2((5));
id1-->id3((1));
id1-->id4((2));
```
::::
:::
```
| 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
```
# Exemple de tri par tas (11/13)
```
| 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `6` (`max` de l'arbre) avec `2`.
* Traiter la racine.
```{.mermaid format=pdf width=150 loc=figs/}
graph TD;
id0((2))-->id1((4));
id0-->id2((5));
id1-->id3((1));
id1-->id4(( ));
style id4 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Trier les tas.
* `2 <=> max(2, 4, 5)`.
* `2 <=> max(2, 1, 4)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((5))-->id1((4));
id0-->id2((2));
id1-->id3((1));
id1-->id4(( ));
style id4 fill:#fff,stroke:#fff
```
::::
:::
```
| 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
```
# Exemple de tri par tas (12/13)
```
| 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `5` (`max` de l'arbre) avec `1`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((4));
id0-->id2((2));
```
::::
:::: column
**But:** Trier les tas.
* `1 <=> max(1, 4, 2)`.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((1));
id0-->id2((2));
```
::::
:::
```
| 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
```
# Exemple de tri par tas (13/13)
```
| 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `4` (`max` de l'arbre) avec `2`.
* Traiter la racine.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((2))-->id1((1));
id0-->id2(( ));
style id2 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Trier les tas. Plus rien à trier
* On fait les 2 dernières étapes en vitesse.
* Échange `2` avec `1`.
* Il reste que `1`. GGWP!
::::
:::
```
| 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
```
# Exercice (10min)
* Trier par tas le tableau
```
| 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
```
* Mettez autant de détails que possible.
* Que constatez-vous?
* Postez le résultat sur matrix.
# L'algorithme du tri par tas (1/2)
\footnotesize
## Deux étapes
1. Entassement: transformer l'arbre en tas.
2. Échanger la racine avec le dernier élément et entasser la racine.
## Pseudo-code d'entassement de l'arbre (15 min, matrix)
. . .
```python
rien tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i de size(tab)-1 à 2
tamisage(tab, 0)
échanger(tab[0], tab[i-1])
rien entassement(tab)
pour i de size(tab)/2-1 à 0
tamisage(tab, i)
rien tamisage(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
tamisage(tab, ind_max)
```
# L'algorithme du tri par tas (2/2)
* Fonctions utilitaires
```python
entier ind_max(tab, i, g, d)
ind_max = i
si g < size(tab) && tab[ind_max] < tab[g]
ind_max = g
si d < size(tab) > d && tab[ind_max] < tab[d]
ind_max = d
retourne ind_max
entier gauche(i)
retourne 2 * i + 1
entier droite(i)
retourne 2 * i + 2
```
<!-- # L'algorithme du tri par tas (3/4)
\footnotesize
## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
. . .
```C
void heapsort(int size, int tab[size]) {
heapify(size, tab);
swap(tab, tab + size - 1);
for (int s = size - 1; s > 1; s--) {
sift_up(s, tab, 0);
swap(tab, tab + s - 1);
}
}
void heapify(int size, int tab[size]) {
for (int i = size / 2 - 1; i >= 0; i--) {
sift_up(size, tab, i);
}
}
void sift_up(int size, int tab[size], int i) {
int ind_max = ind_max3(size, tab, i, left(i), right(i));
if (i != ind_max) {
swap(tab + i, tab + ind_max);
sift_up(size, tab, ind_max);
}
}
```
# L'algorithme du tri par tas (4/4)
\footnotesize
## Fonctions utilitaires
. . .
```C
int ind_max3(int size, int tab[size], int i, int l, int r) {
int ind_max = i;
if (l < size && tab[ind_max] < tab[l]) {
ind_max = l;
}
if (r < size && tab[ind_max] < tab[r]) {
ind_max = r;
}
return ind_max;
}
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
int left(int i) {
return 2 * i + 1;
}
int right(int i) {
return 2 * i + 2;
}
``` -->
slides/cours_18.md
View file @ febfc3f8
---
title: "Arbres et tas"
date: "2024-03-19"
title: "Arbres AVL"
date: "2025-03-21"
---
# Rappel: L'insertion
# Exercice (que vous avez dû faire à la maiso)
* Trier par tas le tableau
```
rien ajout(arbre, clé)
si est_vide(arbre)
arbre = nœud(clé)
sinon
arbre = position(arbre, clé)
si clé < clé(arbre)
gauche(arbre) = nœud(clé)
sinon si clé > clé(arbre)
droite(arbre) = nœud(clé)
sinon
retourne
| 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
```
# La suppression de clé
::: columns
* Mettez autant de détails que possible.
* Que constatez-vous?
* Postez le résultat sur matrix.
:::: column
# L'algorithme du tri par tas (1/2)
## Cas simples:
\footnotesize
* le nœud est absent,
* le nœud est une feuille
* le nœuds a un seul fils.
## Deux étapes
## Une feuille (le 19 p.ex.).
1. Entassement: transformer l'arbre en tas.
2. Échanger la racine avec le dernier élément et entasser la racine.
```{.mermaid format=pdf width=150 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->21
20-->19
```
## Pseudo-code d'entassement de l'arbre (15 min, matrix)
::::
. . .
:::: column
```python
rien tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i de size(tab)-1 à 2
tamisage(tab, 0)
échanger(tab[0], tab[i-1])
## Un seul fils (le 20 p.ex.).
rien entassement(tab)
pour i de size(tab)/2-1 à 0
tamisage(tab, i)
```{.mermaid format=pdf width=400 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->25
20-->18
25-->24
25-->30
5-->4;
5-->8;
style 18 fill:#fff,stroke:#fff,color:#fff
rien tamisage(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
tamisage(tab, ind_max)
```
## Dans tous les cas
* Chercher le nœud à supprimer: utiliser `position()`.
# L'algorithme du tri par tas (2/2)
::::
* Fonctions utilitaires
:::
```python
entier ind_max(tab, i, g, d)
ind_max = i
si g < size(tab) && tab[ind_max] < tab[g]
ind_max = g
si d < size(tab) > d && tab[ind_max] < tab[d]
ind_max = d
retourne ind_max
# La suppression de clé
entier gauche(i)
retourne 2 * i + 1
entier droite(i)
retourne 2 * i + 2
```
::: columns
<!-- # L'algorithme du tri par tas (3/4)
:::: column
\footnotesize
## Cas compliqué
## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
* Le nœud à supprimer à (au moins) deux descendants (10).
. . .
```{.mermaid format=pdf width=400 loc=figs/}
flowchart TB;
10-->20;
10-->5
20-->25
20-->18
25-->24
25-->30
5-->4;
5-->8;
```C
void heapsort(int size, int tab[size]) {
heapify(size, tab);
swap(tab, tab + size - 1);
for (int s = size - 1; s > 1; s--) {
sift_up(s, tab, 0);
swap(tab, tab + s - 1);
}
}
void heapify(int size, int tab[size]) {
for (int i = size / 2 - 1; i >= 0; i--) {
sift_up(size, tab, i);
}
}
void sift_up(int size, int tab[size], int i) {
int ind_max = ind_max3(size, tab, i, left(i), right(i));
if (i != ind_max) {
swap(tab + i, tab + ind_max);
sift_up(size, tab, ind_max);
}
}
```
::::
:::: column
* Si on enlève 10 il se passe quoi?
# L'algorithme du tri par tas (4/4)
. . .
\footnotesize
* On peut pas juste enlever `10` et recoller...
* Proposez une solution bon sang!
## Fonctions utilitaires
. . .
## Solution
* Échange de la valeur à droite dans le sous-arbre de gauche ou
...
* de la valeur de gauche dans le sous-arbre de droite!
* Puis, on retire le nœud.
::::
```C
int ind_max3(int size, int tab[size], int i, int l, int r) {
int ind_max = i;
if (l < size && tab[ind_max] < tab[l]) {
ind_max = l;
}
if (r < size && tab[ind_max] < tab[r]) {
ind_max = r;
}
return ind_max;
}
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
int left(int i) {
return 2 * i + 1;
}
int right(int i) {
return 2 * i + 2;
}
``` -->
:::
# Le pseudo-code de la suppression
## Pour une feuille ou absent (ensemble)
# Les arbres AVL
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(sous_arbre) ou clé(sous_arbre) != clé
retourne vide
sinon
si est_feuille(sous_arbre) et clé(sous_arbre) == clé
nouvelle_feuille = parent(arbre, sous_arbre)
si est_vide(nouvelle_feuille)
arbre = vide
sinon
si gauche(nouvelle_feuille) == sous_arbre
gauche(nouvelle_feuille) = vide
sinon
droite(nouvelle_feuille) = vide
retourne sous_arbre
```
\Huge Les arbres AVL
# Il nous manque le code pour le `parent`
# Un meilleur arbre
## Pseudo-code pour trouver le parent (5min -> matrix)
* Quelle propriété doit satisfaire un arbre pour que la recherche soit $O(\log_2(N))$?
. . .
```
arbre parent(arbre, sous_arbre)
si est_non_vide(arbre)
actuel = arbre
parent = actuel
clé = clé(sous_arbre)
faire
si (clé != clé(actuel))
parent = actuel
si clé < clé(actuel)
actuel = gauche(actuel)
sinon
actuel = droite(actuel)
sinon
retour parent
tant_que (actuel != sous_arbre)
retourne vide
```
* Si on a environ le même nombre de nœuds dans les sous-arbres.
# Le pseudo-code de la suppression
## Définition
\footnotesize
Un arbre binaire est parfaitement équilibré si, pour chaque
nœud, la différence entre les nombres de nœuds des sous-
arbres gauche et droit vaut au plus 1.
## Pour un seul enfant (5min -> matrix)
* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.
* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
. . .
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé)
si est_vide(gauche(sous_arbre)) ou est_vide(droite(sous_arbre))
parent = parent(arbre, sous_arbre)
si est_vide(gauche(sous_arbre))
si droite(parent) == sous_arbre
droite(parent) = droite(sous_arbre)
sinon
gauche(parent) = droite(sous_arbre)
sinon
si droite(parent) == sous_arbreou est_
droite(parent) = gauche(sous_arbre)
sinon
gauche(parent) = gauche(sous_arbre)
retourne sous_arbre
```
# Le pseudo-code de la suppression
\footnotesize
## Pour au moins deux enfants (ensemble)
* $O(\log_2(N))$.
```
arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la clé
si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
max_gauche = position(gauche(sous_arbre), clé)
échange(clé(max_gauche), clé(sous_arbre))
suppression(gauche(sous_arbre), clé)
```
# Exercices (poster sur matrix)
# Équilibre parfait ou pas?
1. Écrire le pseudo-code de l'insertion purement en récursif.
::: columns
. . .
:::: column
```
arbre insertion(arbre, clé)
si est_vide(arbre)
retourne nœud(clé)
si (clé < arbre->clé)
gauche(arbre) = insert(gauche(arbre), clé)
sinon
droite(arbre) = insert(droite(arbre), clé)
retourne arbre
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((W))-->id1((B));
id0-->id8((Y));
id1-->id2((A));
id1-->id9(( ));
id8-->id10((X));
id8-->id11(( ));
style id9 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
# Exercices (poster sur matrix)
::::
2. Écrire le pseudo-code de la recherche purement en récursif.
:::: column
. . .
```
bool recherche(arbre, clé)
si est_vide(arbre)
retourne faux // pas trouvée
si clé(arbre) == clé
retourne vrai // trouvée
si clé < clé(arbre)
retourne recherche(gauche(arbre), clé)
sinon
retourne recherche(droite(arbre), clé)
É
Q
U
I
L
I
B
R
É
```
# Exercices (à la maison)
3. Écrire une fonction qui insère des mots dans un arbre et ensuite affiche
l'arbre.
# Trier un tableau à l'aide d'un arbre binaire
* Tableau représenté comme un arbre binaire.
* Aide à comprendre "comment" trier, mais on ne construit jamais l'arbre.
* Complexité $O(N\log_2 N)$ en moyenne et grande stabilité (pas de cas
dégénérés).
# Lien entre arbre et tableau
::::
* La racine de l'arbre set le premier élément du tableau.
* Les deux fils d'un nœud d'indice $i$, ont pour indices $2i+1$ et $2i+2$:
* Les fils du nœud $i=0$, sont à $2\cdot 0+1=1$ et $2\cdot 0+2=2$.
* Les fils du nœud $i=1$, sont à $2\cdot 1+1=3$ et $2\cdot 1+2=4$.
* Les fils du nœud $i=2$, sont à $2\cdot 2+2=5$ et $2\cdot 1+2=6$.
* Les fils du nœud $i=3$, sont à $2\cdot 3+1=7$ et $2\cdot 3+2=8$.
* Un élément d'indice $i$ a pour parent l'élément $(i-1)/2$ (division entière):
* Le parent du nœud $i=8$ est $(8-1)/2=3$.
* Le parent du nœud $i=7$ est $(7-1)/2=3$.
:::
# Visuellement
# Équilibre parfait ou pas?
::: columns
:::: column
* Où vont les indices correspondant du tableau?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0(( ))-->id1(( ));
id0-->id2(( ));
id1-->id3(( ));
id1-->id4(( ));
id2-->id5(( ));
id2-->id6(( ));
id3-->id7(( ));
id3-->id8(( ));
id4-->id9(( ));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((16))-->id1((10));
id0-->id2((19));
id1-->id3((8));
id1-->id4((12));
id4-->id5((11));
id4-->id6(( ));
id2-->id7((17));
id2-->id8(( ));
id7-->id9(( ));
id7-->id10((18));
style id6 fill:#fff,stroke:#fff
style id8 fill:#fff,stroke:#fff
style id9 fill:#fff,stroke:#fff
```
::::
:::: column
* Les flèche de gauche à droite, parent -> enfants.
* Les flèche de droite à gauche, enfants -> parent.
. . .
```
P
A
S
![Dualité tableau arbre binaire.](figs/heap_tree.svg)
É
Q
U
I
L
I
B
R
É
```
::::
:::
**Propriétés:**
# Arbres AVL
1. les feuilles sont toutes sur l'avant dernier ou dernier niveau.
2. les feuilles de profondeur maximale sont "tassée" à gauche.
\footnotesize
# Le tas (ou heap)
* Quand est-ce qu'on équilibre un arbre?
## Définition
. . .
* Un arbre est un tas, si la valeur de chacun de ses descendants est inférieure
ou égale à sa propre valeur.
* A l'insertion/suppression.
* Maintenir un arbre en état d'équilibre parfait: cher (insertion, suppression).
* On peut "relaxer" la condition d'équilibre: profondeur (hauteur) au lieu du
nombre de nœuds:
* La hauteur $\sim\log_2(N)$.
## Exemples (ou pas)
## Définition
```
16 8 14 6 2 10 12 4 5 # Tas
16 14 8 6 2 10 12 4 5 # Non-tas, 10 > 8 et 12 > 8
```
Un arbre AVL (Adelson-Velskii et Landis) est un arbre binaire de recherche dans
lequel, pour chaque nœud, la différence de hauteur entre le sous-arbre gauche et droit vaut au plus 1.
## Exercices (ou pas)
* Relation entre nœuds et hauteur:
$$
\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.
$$
* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.
```
19 18 12 12 17 1 13 4 5 # Tas ou pas tas?
19 18 16 12 17 1 12 4 5 # Tas ou pas tas?
```
# Notation
* `hg`: hauteur du sous-arbre gauche.
* `hd`: hauteur du sous-arbre droit.
* `facteur d'équilibre = fe = hd - hg`
* Que vaut `fe` si l'arbre est AVL?
. . .
```
19 18 12 12 17 1 13 4 5 # Pas tas! 13 > 12
19 18 16 12 17 1 12 4 5 # Tas!
```
* `fe = {-1, 0, 1}`
# Exemple de tri par tas (1/13)
```
| 1 | 16 | 5 | 12 | 4 | 2 | 8 | 10 | 6 | 7 |
```
# AVL ou pas?
::: columns
:::: column
* Quel est l'arbre que cela représente?
. . .
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((4));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((7));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((12))-->id1((10));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* On commence à l'indice $N/2 = 5$: `4`.
* `7 > 4` (enfant `>` parent).
* intervertir `4` et `7`.
. . .
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
```
A
V
L
```
::::
:::
. . .
```
* *
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
# Exemple de tri par tas (2/13)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
# AVL ou pas?
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* On continue à l'indice $N/2-1 = 4$: `12`.
* Déjà un tas, rien à faire.
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
id4-->id5((37));
id4-->id6(( ));
style id6 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
. . .
* On continue à l'indice $N/2-2 = 3$: `5`.
* `5 < 8`, échanger `8` et `5` (aka `max(2, 5, 8)`)
```
P
A
S
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
A
V
L
```
::::
:::
. . .
```
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Exemple de tri par tas (3/13)
# Insertion dans un arbre AVL (1/N)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-1 = 4$: `12`.
* Déjà un tas, rien à faire.
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((5));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((8));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((12))-->id1((1));
id0-->id2((19));
```
::::
:::: column
**But:** Transformer l'arbre en tas.
. . .
* Indice $N/2-2 = 3$: `5`.
* `5 < 8`, `5 <=> max(2, 5, 8)`
* `hd = hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((12))-->id1((1));
id0-->id2((19));
id1-->id4(( ));
id1-->id5((4));
style id4 fill:#fff,stroke:#fff
```
* `fe = -1`
::::
:::
```
* *
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Exemple de tri par tas (4/13)
# Insertion dans un arbre AVL (2/N)
```
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-3 = 1$: `16`.
* Déjà un tas, rien à faire.
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((16));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((18));
id2-->id4(( ));
style id4 fill:#fff,stroke:#fff
```
::::
:::: column
**But:** Transformer l'arbre en tas.
. . .
* Indice $N/2-4 = 1$: `1`.
* `1 < 16 && 1 < 8`, `1 <=> max(1, 16, 8)`
* `hd < hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((1));
id0-->id2((8));
id1-->id3((12));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
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`
::::
:::
```
* *
| 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
# Insertion dans un arbre AVL (3/N)
\footnotesize
# Exemple de tri par tas (5/13)
```
| 16 | 1 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Recommencer avec `1`.
* `1 <=> max(1, 12, 7)`.
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((12));
id0-->id2((8));
id1-->id3((1));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((10));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
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
**But:** Transformer l'arbre en tas.
. . .
* Recommencer avec `1`.
* `1 <=> max(1, 10, 6)`.
* `hd < hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((12));
id0-->id2((8));
id1-->id3((10));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((6));
id4-->id9((4));
id4-->id10(( ));
style id10 fill:#fff,stroke:#fff
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
```
::::
:::
```
* * *
| 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
```
**Déséquilibre!** Que vaut `fe`?
. . .
* L'arbre est un tas.
* `fe = 2`
# Exemple de tri par tas (6/13)
# Les cas de déséquilibre
```
| 16 | 12 | 8 | 10 | 7 | 2 | 5 | 1 | 6 | 4 |
```
::: columns
:::: column
**But:** Trier les tas.
## Cas 1a
* Échanger la racine, `16` (`max` de l'arbre) avec `4`.
* Traiter la racine.
* `u`, `v`, `w` même hauteur.
* déséquilibre en `B` après insertion dans `u`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((12));
id0-->id2((8));
id1-->id3((10));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((6));
```
![Après insertion](figs/cas1a_gauche.png)
::::
:::: column
**But:** Trier les tas.
## Cas 1a
* `4 <=> max(4, 12, 8)`.
* `4 <=> max(4, 10, 7)`.
* `4 <=> max(4, 1, 6)`.
* Comment rééquilibrer?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((10));
id0-->id2((8));
id1-->id3((6));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8((4));
```
. . .
* ramène `u`, `v` `w` à la même hauteur.
* `v` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas1a_droite.png)
::::
:::
```
| 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
```
# Les cas de déséquilibre
# Exemple de tri par tas (7/13)
::: 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
```
| 12 | 10 | 8 | 6 | 7 | 2 | 5 | 1 | 4 || 16
```
::: columns
:::: column
**But:** Trier les tas.
## Cas 2a
* Échanger la racine, `12` (`max` de l'arbre) avec `4`.
* Traiter la racine.
* `h(v1)=h(v2), h(u)=h(w)`.
* déséquilibre en `C` après insertion dans `v2`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((10));
id0-->id2((8));
id1-->id3((6));
id1-->id4((7));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8(( ));
style id8 fill:#fff,stroke:#fff
```
![Après insertion](figs/cas2a_gauche.png)
::::
:::: column
**But:** Trier les tas.
## Cas 2a
* `4 <=> max(4, 10, 8)`.
* `4 <=> max(4, 6, 7)`.
* Comment rééquilibrer?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((10))-->id1((7));
id0-->id2((8));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((5));
id3-->id7((1));
id3-->id8(( ));
style id8 fill:#fff,stroke:#fff
```
. . .
* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
* `v2` à droite de `B` (gauche de `C`)
* `B` à droite de `A` (gauche de `C`)
* `v1` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas2a_droite.png)
::::
:::
# Les cas de déséquilibre
::: columns
:::: column
## Cas 2b (symétrique 2a)
![Après insertion](figs/cas2b_gauche.png)
::::
:::: column
## Cas 2b (symétrique 2a)
* Comment rééquilibrer?
. . .
![Après équilibrage](figs/cas2b_droite.png)
::::
:::
# Le facteur d'équilibre (balance factor)
## Définition
```
| 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))
```
# Exemple de tri par tas (8/13)
## Valeurs possibles?
. . .
```
| 10 | 7 | 8 | 6 | 4 | 2 | 5 | 1 || 12 | 16
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
**But:** Trier les tas.
## Sous-arbre gauche (avant)
* Échanger la racine, `10` (`max` de l'arbre) avec `1`.
* Traiter la racine.
```
fe(P) = 1
fe(P) = 0
fe(P) = -1
```
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((7));
id0-->id2((8));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((5));
::::
:::: 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
**But:** Trier les tas.
## Sous-arbre droit (après)
* `1 <=> max(1, 7, 8)`.
* `5 <=> max(1, 2, 5)`.
. . .
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((8))-->id1((7));
id0-->id2((5));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6((1));
```
=> fe(P) = 0
=> fe(P) = +1
=> fe(P) = +2 // Rééquilibrer P
```
::::
:::
# Rééquilibrage
## Lien avec les cas vus plus tôt
```
| 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
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
```
# Exemple de tri par tas (9/13)
## 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
```
| 8 | 7 | 5 | 6 | 4 | 2 | 1 || 10 | 12 | 16
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, pseudo-code (5min)?
. . .
```
arbre rotation_droite(arbre P)
si est_non_vide(P)
Q = gauche(P)
gauche(P) = droite(Q)
droite(Q) = P
retourne Q
retourne P
```
<!-- ```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
**But:** Trier les tas.
* Échanger la racine, `8` (`max` de l'arbre) avec `1`.
* Traiter la racine.
## Quelle rotation et sur quel noeud (5 ou 6)?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((7));
id0-->id2((5));
id1-->id3((6));
id1-->id4((4));
id2-->id5((2));
id2-->id6(( ));
style id6 fill:#fff,stroke:#fff
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
**But:** Trier les tas.
. . .
* `1 <=> max(1, 7, 5)`.
* `1 <=> max(1, 6, 4)`.
## Sur le plus jeune évidemment!
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((7))-->id1((6));
id0-->id2((5));
id1-->id3((1));
id1-->id4((4));
id2-->id5((2));
id2-->id6(( ));
style id6 fill:#fff,stroke:#fff
id0((5))-->id1((1));
id0-->id2((8));
id2-->id3((6));
id2-->id4((9));
```
::::
:::
```
| 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
```
* Cas `1a/b` *check*!
# Exemple de tri par tas (10/13)
```
| 7 | 6 | 5 | 1 | 4 | 2 || 8 | 10 | 12 | 16
```
# 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
**But:** Trier les tas.
## Insérer 50, ex 10min (matrix)
* Échanger la racine, `7` (`max` de l'arbre) avec `2`.
* Traiter la racine.
```{.mermaid format=pdf width=150 loc=figs/}
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((2))-->id1((6));
id0-->id2((5));
id1-->id3((1));
id1-->id4((4));
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
**But:** Trier les tas.
. . .
* `2 <=> max(2, 6, 5)`.
* `2 <=> max(2, 1, 4)`.
## Où se fait la rotation?
```{.mermaid format=pdf width=150 loc=figs/}
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((6))-->id1((4));
id0-->id2((5));
id1-->id3((1));
id1-->id4((2));
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
```
::::
:::
```
| 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
```
# Exercices
# Exemple de tri par tas (11/13)
::: columns
```
| 6 | 4 | 5 | 1 | 2 || 8 | 10 | 12 | 16
:::: 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
```
::: columns
::::
:::: column
**But:** Trier les tas.
. . .
* Échanger la racine, `6` (`max` de l'arbre) avec `2`.
* Traiter la racine.
## Rotation à droite en 71
```{.mermaid format=pdf width=150 loc=figs/}
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((2))-->id1((4));
id0-->id2((5));
id1-->id3((1));
id1-->id4(( ));
style id4 fill:#fff,stroke:#fff
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
```
::::
:::: column
:::
# Exercice de la mort
Soit l’arbre AVL suivant:
**But:** Trier les tas.
::: columns
* `2 <=> max(2, 4, 5)`.
* `2 <=> max(2, 1, 4)`.
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((5))-->id1((4));
id0-->id2((2));
id1-->id3((1));
id1-->id4(( ));
style id4 fill:#fff,stroke:#fff
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’equilgaucheibre.
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.
::::
:::
```
| 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
```
# Encore un petit exercice
# Exemple de tri par tas (12/13)
* Insérer les nœuds suivants dans un arbre AVL
```
| 5 | 4 | 2 | 1 || 6 | 8 | 10 | 12 | 16
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
**But:** Trier les tas.
* Échanger la racine, `5` (`max` de l'arbre) avec `1`.
* Traiter la racine.
## Algorithme par problème: supprimer 10
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((1))-->id1((4));
id0-->id2((2));
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
**But:** Trier les tas.
. . .
* `1 <=> max(1, 4, 2)`.
## Algorithme par problème: supprimer 10
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((4))-->id1((1));
id0-->id2((2));
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
```
::::
:::
```
| 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
```
# Exemple de tri par tas (13/13)
# Suppression dans un arbre AVL
```
| 4 | 1 | 2 || 5 | 6 | 8 | 10 | 12 | 16
```
::: columns
:::: column
**But:** Trier les tas.
* Échanger la racine, `4` (`max` de l'arbre) avec `2`.
* Traiter la racine.
## Algorithme par problème: supprimer 8
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((2))-->id1((1));
id0-->id2(( ));
style id2 fill:#fff,stroke:#fff
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
**But:** Trier les tas. Plus rien à trier
. . .
* On fait les 2 dernières étapes en vitesse.
* Échange `2` avec `1`.
* Il reste que `1`. GGWP!
## 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
```
::::
:::
```
| 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
```
# Suppression dans un arbre AVL
# Exercice (10min)
::: columns
* Trier par tas le tableau
:::: column
```
| 1 | 2 | 4 | 5 | 6 | 8 | 10 | 12 | 16
```
## Algorithme par problème: rotation de 12
* Mettez autant de détails que possible.
* Que constatez-vous?
* Postez le résultat sur matrix.
```{.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
```
# L'algorithme du tri par tas (1/2)
::::
\footnotesize
:::: column
## Deux étapes
. . .
1. Entassement: transformer l'arbre en tas.
2. Échanger la racine avec le dernier élément et entasser la racine.
1. On supprime comme d'habitude.
2. On rééquilibre si besoin à l'endroit de la suppression.
## Pseudo-code d'entassement de l'arbre (15 min, matrix)
* Facile non?
. . .
```python
rien tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i de size(tab)-1 à 2
tamisage(tab, 0)
échanger(tab[0], tab[i-1])
rien entassement(tab)
pour i de size(tab)/2-1 à 0
tamisage(tab, i)
* Plus dur....
rien tamisage(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
tamisage(tab, ind_max)
```
::::
# L'algorithme du tri par tas (2/2)
:::
* Fonctions utilitaires
# Suppression dans un arbre AVL 2.0
```python
entier ind_max(tab, i, g, d)
ind_max = i
si tab[ind_max] < tab[g] && size(tab) > g
ind_max = g
si tab[ind_mx] < tab[d] && size(tab) > d
ind_max = d
retourne ind_max
::: columns
entier gauche(i)
retourne 2 * i + 1
entier droite(i)
retourne 2 * i + 2
```
:::: column
## Algorithme par problème: suppression de 30
<!-- # L'algorithme du tri par tas (3/4)
```{.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
```
\footnotesize
::::
## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
:::: column
. . .
```C
void heapsort(int size, int tab[size]) {
heapify(size, tab);
swap(tab, tab + size - 1);
for (int s = size - 1; s > 1; s--) {
sift_up(s, tab, 0);
swap(tab, tab + s - 1);
}
}
void heapify(int size, int tab[size]) {
for (int i = size / 2 - 1; i >= 0; i--) {
sift_up(size, tab, i);
}
}
void sift_up(int size, int tab[size], int i) {
int ind_max = ind_max3(size, tab, i, left(i), right(i));
if (i != ind_max) {
swap(tab + i, tab + ind_max);
sift_up(size, tab, ind_max);
}
}
## 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
```
# L'algorithme du tri par tas (4/4)
::::
\footnotesize
:::
## Fonctions utilitaires
# 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
. . .
```C
int ind_max3(int size, int tab[size], int i, int l, int r) {
int ind_max = i;
if (l < size && tab[ind_max] < tab[l]) {
ind_max = l;
}
if (r < size && tab[ind_max] < tab[r]) {
ind_max = r;
}
return ind_max;
}
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
int left(int i) {
return 2 * i + 1;
}
int right(int i) {
return 2 * i + 2;
}
``` -->
## 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
```
::::
:::
[^2]: Copyright cours de mathématiques pendant trop d'années.
# 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 peut déséquilibrer un autre nœud.
3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
slides/cours_19.md
View file @ febfc3f8
---
title: "Arbres AVL"
date: "2024-03-25"
title: "Arbres AVL et arbres quaternaires"
date: "2025-03-28"
---
# Tri par tas: algorithme
# Rappel: Algorithme d'insertion
\footnotesize
* 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.
* Vous souvenez-vous de l'algorithme?
# Rappel: les cas de déséquilibre
. . .
::: columns
```python
rien tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i de size(tab)-1 à 2
tamisage(tab, 0)
échanger(tab[0], tab[i-1])
rien entassement(tab)
pour i de size(tab)/2-1 à 0
tamisage(tab, i)
rien tamisage(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
tamisage(tab, ind_max)
```
:::: column
## Cas 1a
* `u`, `v`, `w` même hauteur.
* déséquilibre en `B` après insertion dans `u`
# Un meilleur arbre
![Après insertion](figs/cas1a_gauche.png)
* Quelle propriété doit satisfaire un arbre pour que la recherche soit $O(\log_2(N))$?
::::
. . .
:::: column
* Si on a environ le même nombre de nœuds dans les sous-arbres.
## Cas 1a
## Définition
* Comment rééquilibrer?
Un arbre binaire est parfaitement équilibré si, pour chaque
nœud, la différence entre les nombres de nœuds des sous-
arbres gauche et droit vaut au plus 1.
. . .
* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.
* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
* ramène `u`, `v` `w` à la même hauteur.
* `v` à droite de `A` (gauche de `B`)
. . .
![Après équilibrage](figs/cas1a_droite.png)
::::
* $O(\log_2(N))$.
:::
# Rappel: Les cas de déséquilibre
# Équilibre parfait ou pas?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((W))-->id1((B));
id0-->id8((Y));
id1-->id2((A));
id1-->id9(( ));
id8-->id10((X));
id8-->id11(( ));
style id9 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
## Cas 2a
* `h(v1)=h(v2), h(u)=h(w)`.
* déséquilibre en `C` après insertion dans `v2`
![Après insertion](figs/cas2a_gauche.png)
::::
:::: column
## Cas 2a
* Comment rééquilibrer?
. . .
```
É
Q
U
I
L
I
B
R
É
```
* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
* `v2` à droite de `B` (gauche de `C`)
* `B` à droite de `A` (gauche de `C`)
* `v1` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas2a_droite.png)
::::
:::
# Équilibre parfait ou pas?
# Rappel: Rééquilibrage
::: columns
## Rotation simple
:::: column
![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((10));
id0-->id2((19));
id1-->id3((8));
id1-->id4((12));
id4-->id5((11));
id4-->id6(( ));
id2-->id7((17));
id2-->id8(( ));
id7-->id9(( ));
id7-->id10((18));
style id6 fill:#fff,stroke:#fff
style id8 fill:#fff,stroke:#fff
style id9 fill:#fff,stroke:#fff
```
# Rappel: La rotation gauche-droite
::::
## Le cas 2a/b
:::: column
![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
. . .
# Un petit exercice
* Insérer les nœuds suivants dans un arbre AVL
```
P
A
S
É
Q
U
I
L
I
B
R
É
25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40
| 50 | 55 | 30 | 15
```
::::
:::
# Arbres AVL
```
\footnotesize
* Quand est-ce qu'on équilibre un arbre?
. . .
* A l'insertion/suppression.
* Maintenir un arbre en état d'équilibre parfait: cher (insertion, suppression).
* On peut "relaxer" la condition d'équilibre: profondeur (hauteur) au lieu du
nombre de nœuds:
* La hauteur $\sim\log_2(N)$.
## Définition
Un arbre AVL (Adelson-Velskii et Landis) est un arbre binaire de recherche dans
lequel, pour chaque nœud, la différence de hauteur entre le sous-arbre gauche et droit vaut au plus 1.
* Relation entre nœuds et hauteur:
$$
\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.
$$
* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.
# Notation
* `hg`: hauteur du sous-arbre gauche.
* `hd`: hauteur du sous-arbre droit.
* `facteur d'équilibre = fe = hd - hg`
* Que vaut `fe` si l'arbre est AVL?
. . .
```
* `fe = {-1, 0, 1}`
# La suppression dans un arbre AVL
\Huge La suppression dans un arbre AVL
# AVL ou pas?
# Suppression dans un arbre AVL
::: columns
:::: column
## Algorithme par problème: supprimer 10
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((10));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
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
```
::::
......@@ -200,31 +147,57 @@ graph TD;
. . .
```
A
V
L
## 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
```
::::
:::
# AVL ou pas?
# Suppression dans un arbre AVL
::: columns
:::: column
## Algorithme par problème: supprimer 8
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
id4-->id5((37));
id4-->id6(( ));
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
```
::::
......@@ -233,36 +206,54 @@ graph TD;
. . .
```
P
A
S
## Algorithme par problème: rotation de 12
A
V
L
```{.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
```
::::
:::
# Insertion dans un arbre AVL (1/N)
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
# Suppression dans un arbre AVL
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
## Algorithme par problème: rotation de 12
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
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
```
::::
......@@ -271,42 +262,46 @@ graph TD;
. . .
* `hd = hg`
1. On supprime comme d'habitude.
2. On rééquilibre si besoin à l'endroit de la suppression.
* Facile non?
```{.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`
* Plus dur....
::::
:::
# Insertion dans un arbre AVL (2/N)
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
# Suppression dans un arbre AVL 2.0
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
## Algorithme par problème: suppression de 30
```{.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
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
```
::::
......@@ -315,51 +310,58 @@ graph TD;
. . .
* `hd < hg`
## Algorithme par problème: rotation GD autour de 40
```{.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));
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
```
* `fe = 0`
::::
:::
# Insertion dans un arbre AVL (3/N)
\footnotesize
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
# Suppression dans un arbre AVL 2.0
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
## Argl! 50 est déséquilibré!
```{.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
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
```
::::
......@@ -368,868 +370,526 @@ graph TD;
. . .
* `hd < hg`
## Algorithme par problème: rotation DG autour de 50
```{.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)
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
```
::::
:::: 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)
# 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 peut déséquilibrer un autre nœud sur le chemin menant au noeud supprimé.
3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer en remontant le chemin.
:::
# Les cas de déséquilibre
# Les arbres quaternaires
\Huge Les arbres quaternaires
::: columns
:::: column
# Les arbres quaternaires
## Cas 1b (symétrique 1a)
## Définition
![Après insertion](figs/cas1b_gauche.png)
Arbre dont chaque nœud a 4 enfants ou aucun.
::::
![Un exemple d'arbre quaternaire.](figs/quad_ex.svg)
:::: column
# Les arbres quaternaires
## Cas 1b (symétrique 1a)
## Cas d'utilisation
* Comment rééquilibrer?
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).
![Après équilibrage](figs/cas1b_droite.png)
## Cas d'utilisation: images
::::
* Stockage: compression.
* Transformations: symétries, rotations, etc.
:::
## Cas d'utilisation: simulation
# Les cas de déséquilibre
* Indexation spatiale.
* Détection de collisions.
* Simulation de galaxies (algorithme de Barnes-Hut).
# Exemple de compression
::: columns
:::: column
:::: {.column width=30%}
## Cas 2a
## Comment représenter l'image
* `h(v1)=h(v2), h(u)=h(w)`.
* déséquilibre en `C` après insertion dans `v2`
![Après insertion](figs/cas2a_gauche.png)
![Image noir/blanc.](figs/board_blacked_parts.svg)
::::
:::: column
:::: {.column width=70%}
## Cas 2a
* Comment rééquilibrer?
## Sous la forme d'un arbre quaternaire?
. . .
* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
* `v2` à droite de `B` (gauche de `C`)
* `B` à droite de `A` (gauche de `C`)
* `v1` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas2a_droite.png)
::::
:::
# Les cas de déséquilibre
::: columns
:::: column
## Cas 2b (symétrique 2a)
![L'arbre quaternaire correspondant.](figs/quad_img.svg)
![Après insertion](figs/cas2b_gauche.png)
::::
:::: column
## Cas 2b (symétrique 2a)
* Comment rééquilibrer?
**Économie?**
. . .
![Après équilibrage](figs/cas2b_droite.png)
Image 64 pixels, arbre 25 nœuds.
::::
:::
# Le facteur d'équilibre (balance factor)
## Définition
# Structure de données
```
fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))
```
::: columns
:::: {.column width=50%}
## Valeurs possibles?
## Pseudo-code?
. . .
```python
struct node
info
node sup_gauche, sup_droit,
inf_gauche, inf_droit
```
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
![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
* 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 width=50%}
:::: column
## En C?
## Sous-arbre gauche (avant)
. . .
```C
struct _node {
int info;
struct _node *sup_left;
struct _node *sup_right;
struct _node *inf_left;
struct _node *inf_right;
};
```
fe(P) = 1
fe(P) = 0
fe(P) = -1
```
::::
:::: column
## Sous-arbre gauche (après)
* Pourquoi le `*` est important?
. . .
```
=> fe(P) = 0
=> fe(P) = -1
=> fe(P) = -2 // Rééquilibrer P
```
* Type récursif => taille inconnue à la compilation.
::::
:::
# 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
# Une fonctionnalité simple
::: columns
\footnotesize
:::: column
## La fonction `est_feuille(noeud)`
## Sous-arbre droit (avant)
* Problème avec cette implémentation?
```
fe(P) = 1
fe(P) = 0
fe(P) = -1
```python
bool est_feuille(noeud)
retourne
est_vide(sup_gauche(noeud)) &&
est_vide(sup_droit(noeud)) &&
est_vide(inf_gauche(noeud)) &&
est_vide(inf_droit(noeud))
```
::::
:::: column
. . .
## Sous-arbre droit (après)
* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
* Facile d'en oublier un!
* Comment changer la structure pour que ça soit moins terrible?
. . .
```python
struct node
info
node enfant[4]
```
=> fe(P) = 0
=> fe(P) = +1
=> fe(P) = +2 // Rééquilibrer P
```
::::
:::
# Structure de données
# Rééquilibrage
## En C?
## Lien avec les cas vus plus tôt
. . .
```C
typedef struct _node {
int info;
struct _node *child[4];
} node;
```
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
```
## Fonction `is_leaf(node *tree)`?
## Dessiner les différents cas, sur le dessin ci-dessous
. . .
![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
```C
bool is_leaf(node *tree) {
return (NULL == tree->child[0]); // only first matters
}
```
# La rotation
# Problème à résoudre
## La rotation gauche (5min, matrix)
* Construire un arbre quaternaire à partir d'une image:
* Créer l'arbre (allouer la mémoire pour tous les nœuds)
* Remplir l'arbre avec les valeurs des pixels
* Compression de l'image:
* Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
* Si les pixels ne dévient pas trop, on supprime le quadrant (avec perte)
![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)
# Création de l'arbre
## Comment créer un arbre de profondeur `prof` (3min)?
. . .
\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
```python
arbre creer_arbre(prof)
n = nouveau_noeud() # alloue la mémoire
si prof > 0
pour i = 0 à 3
n.enfant[i] = creer_arbre(prof-1)
retourne n
```
# La rotation en C (1/2)
## En `C` (3 min, matrix)?
## 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
```C
node *qt_create(int depth) {
node *n = calloc(1, sizeof(node));
if (depth > 0) {
for (int i = 0; i < 4; ++i) {
n->child[i] = qt_create(depth-1);
}
}
return n;
}
```
## Écrire le code C correspondant (5min, matrix)
# Le nombre de nœuds?
1. Structure de données
2. Fonction `tree_t rotation_left(tree_t tree)`
## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
. . .
\footnotesize
```C
typedef struct _node {
int key;
struct _node *left, *right;
int bf; // balance factor
} node;
typedef node *tree_t;
entier nombre_nœuds(arbre)
si est_feuille(arbre)
retourne 1
sinon
somme = 1
pour i de 0 à 3
somme += nombre_nœuds(arbre.enfant[i])
retourne somme
```
# La rotation en C (2/2)
# Le nombre de nœuds?
\footnotesize
## Comment implémenter la fonction en C (3min, matrix)?
. . .
```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;
int size(node *qt) {
if (is_leaf(qt)) {
return 1;
} else {
int sum = 1;
for (int i = 0; i < 4; ++i) {
sum += size(qt->child[i]);
}
return sum;
}
return subtree;
}
```
. . .
# La profondeur en C?
* Et la rotation à droite, pseudo-code (5min)?
## Implémentation (5min, matrix)
. . .
```
arbre rotation_droite(arbre P)
si est_non_vide(P)
Q = gauche(P)
gauche(P) = droite(Q)
droite(Q) = P
retourne Q
retourne P
```
\footnotesize
<!-- ```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;
```C
int max(int x, int y) {
return (x >= y ? x : y);
}
int max_depth(int depths[4]) {
int m = depths[0];
for (int i = 1; i < 4; ++i) {
m = max(m, depths[i]);
}
return m;
}
int depth(node *qt) {
int depths[] = {0, 0, 0, 0};
if (is_leaf(qt)) {
return 0;
} else {
for (int i = 0; i < 4; ++i) {
depths[i] = depth(qt->child[i]);
}
return 1 + max_depth(depths);
}
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
# Fonctions utiles (1/4)
## Quelle rotation et sur quel noeud (5 ou 6)?
## Comment remplir un arbre depuis une matrice?
```{.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));
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
::::
:::
* Cas `1a/b` *check*!
# La rotation gauche-droite
## Là c'est plus difficile (cas 2a/b)
## Quel arbre cela représente?
![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
. . .
# Exercices
![L'arbre correspondant](figs/quad_img_simple.svg)
## Faire l'implémentation de la double rotation (pas corrigé, 5min)
# Fonctions utiles (2/4)
# Exercices
* On veut transférer la valeur d'une case ligne/colonne dans une feuille.
* Comment?
::: columns
:::: column
:::: {.column width=40%}
## Insérer 50, ex 10min (matrix)
## Soit `ligne=2`, `colonne=3`
```{.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
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
::::
:::
# Exercices
:::: {.column width=70%}
::: 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
```
## Trouver un algorithme
::::
![Déterminer un algorithme.](figs/quad_img_simple.svg)
:::: column
* Quelle feuille pour 31 (`li=2`, `co=3`)?
* Plus important: quel chemin?
. . .
## 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
```
* `co -> G/D`, `li -> S/I`,
* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
* Comment généraliser?
::::
:::
# Exercice de la mort
Soit l’arbre AVL suivant:
# Fonctions utiles (3/4)
::: columns
:::: column
:::: {.column width=40%}
```{.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’equilgaucheibre.
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.
::::
:::
# Encore un petit exercice
* Insérer les nœuds suivants dans un arbre AVL
## Soit `ligne=2`, `colonne=3`
```
25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40
| 50 | 55 | 30 | 15
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
## Un à un et le/la premier/ère qui poste la bonne réponse sur matrix a un point
# Suppression dans un arbre AVL
::::
:::: {.column width=70%}
::: columns
## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
:::: column
![Déterminer un algorithme.](figs/quad_img_simple.svg)
## 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
* Comment généraliser?
. . .
## 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
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
```
::::
:::
# Suppression dans un arbre AVL
::: columns
# Fonctions utiles (4/4)
:::: column
\footnotesize
## Algorithme par problème: supprimer 8
## Pseudo-code
```{.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
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
```
::::
:::: column
## Écrire le code `C` correspondant (5min, matrix)
. . .
## Algorithme par problème: rotation de 12
```C
```{.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.
# Remplir l'arbre
* Facile non?
## A partir d'une matrice (pseudo-code, 5min, matrix)?
. . .
* 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
```C
arbre matrice_vers_arbre(matrice)
arbre = creer_arbre(profondeur)
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
noeud.info = matrice[co][li]
retourne arbre
```
::::
. . .
:::: column
## A partir d'une matrice (C, 5min, matrix)?
. . .
## Algorithme par problème: rotation GD autour de 40
\footnotesize
```{.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
```C
node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth) {
node *qt = qt_create(depth);
for (int li = 0; li < nb_li; ++li) {
for (int co = 0; co < nb_co; ++co) {
node *current = position(li, co, qt);
current->info = matrix[li][co];
}
}
return qt;
}
```
::::
:::
# Suppression dans un arbre AVL 2.0
# Remplir la matrice
::: columns
## A partir de l'arbre (pseudo-code, 3min, matrix)?
:::: column
. . .
## Argl! 50 est déséquilibré!
\footnotesize
```{.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
```C
matrice arbre_vers_matrice(arbre)
matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
matrice[co][li] = noeud.info
retourne matrice
```
::::
. . .
:::: column
## A partir de l'arbre (C, 3min, matrix)?
. . .
## Algorithme par problème: rotation DG autour de 50
\footnotesize
```{.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
```C
void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co]) {
for (int li = 0; li < nb_li; ++li) {
for (int co = 0; co < nb_co; ++co) {
node *current = position(li, co, qt);
matrix[li][co] = current->info;
}
}
}
```
::::
:::
# 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 peut déséquilibrer un autre nœud.
3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
slides/cours_2.md
View file @ febfc3f8
---
title: "Introduction aux algorithmes"
date: "2023-09-26"
title: "Introduction aux algorithmes II"
date: "2024-09-23"
---
# Rappel
......
slides/cours_20.md
View file @ febfc3f8
---
title: "Arbres AVL et arbres quaternaires"
date: "2024-04-09"
title: "Arbres quaternaires"
date: "2025-04-04"
---
# Rappel: Algorithme d'insertion
# Rappel sur les arbres quaternaires
* 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.
## Définition?
# Rappel: les cas de déséquilibre
::: columns
. . .
:::: column
* Arbre dont chaque nœud a 4 enfants ou aucun.
## Cas 1a
## Utilisation dans ce cours?
* `u`, `v`, `w` même hauteur.
* déséquilibre en `B` après insertion dans `u`
. . .
![Après insertion](figs/cas1a_gauche.png)
* Stockage/compression d'image
* Chaque pixel correspond à une feuille
* Des portions de l'image peuvent être compressées sans/avec perte
::::
:::: column
## Cas 1a
# Transformations avec un arbre quaternaire
* Comment rééquilibrer?
## A faire
. . .
* Symétrie axiale (horizontale/verticale).
* Rotation quart de cercle (gauche/droite).
* Compression.
* ramène `u`, `v` `w` à la même hauteur.
* `v` à droite de `A` (gauche de `B`)
# La symétrie verticale
![Après équilibrage](figs/cas1a_droite.png)
## Que donne la symétrie verticale de
::::
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
:::
. . .
# Rappel: Les cas de déséquilibre
```
SG=0 | SD=1
4 | 4 | 12 | 21
4 | 4 | 7 | 9
------------------
31 | 0 | 1 | 1
27 | 3 | 1 | 1
IG=2 | ID=3
```
# La symétrie d'axe vertical
::: columns
## Comment faire sur une matrice (3min, matrix)?
:::: column
. . .
## Cas 2a
\footnotesize
* `h(v1)=h(v2), h(u)=h(w)`.
* déséquilibre en `C` après insertion dans `v2`
```C
matrice symétrie(matrice)
pour i de 0 à nb_lignes(matrice)
pour j de 0 à nb_colonnes(matrice)/2
échanger(matrice[i][j], matrice[i][nb_colonnes(matrice)-1-j])
retourne matrice
```
![Après insertion](figs/cas2a_gauche.png)
# La symétrie d'axe vertical
::::
## Comment faire sur un arbre?
:::: column
* Faire un dessin de l'arbre avant/après (5min, matrix)
## Cas 2a
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 12 | 21
9 | 7 | 4 | 4 4 | 4 | 7 | 9
----------------- => ----------------
1 | 1 | 0 | 31 31 | 0 | 1 | 1
1 | 1 | 3 | 27 27 | 3 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
```
* Comment rééquilibrer?
* Écrire le pseudo-code (3min, matrix)
. . .
* ramène `u`, `v2`, `w` à la même hauteur (`v1` pas tout à fait).
* `v2` à droite de `B` (gauche de `C`)
* `B` à droite de `A` (gauche de `C`)
* `v1` à droite de `A` (gauche de `B`)
\footnotesize
```C
arbre symétrie(arbre)
si !est_feuille(arbre)
échanger(arbre.enfant[0], arbre.enfant[1])
échanger(arbre.enfant[2], arbre.enfant[3])
pour i de 0 à 3
symétrie(arbre.enfant[i])
retourne arbre
```
# La symétrie d'axe horizontal
![Après équilibrage](figs/cas2a_droite.png)
* Trivial de faire l'axe horizontal (exercice à la maison)
::::
# Rotation d'un quart de cercle
:::
## Comment faire sur un arbre?
# Rappel: Rééquilibrage
* Faire un dessin de l'arbre avant/après (5min, matrix)
## Rotation simple
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 31 | 27
9 | 7 | 4 | 4 4 | 4 | 0 | 3
----------------- => -----------------
1 | 1 | 0 | 31 12 | 7 | 1 | 1
1 | 1 | 3 | 27 21 | 9 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
```
# Rappel: La rotation gauche-droite
* Écrire le pseudo-code (3min, matrix)
. . .
## Le cas 2a/b
```C
rien rotation_gauche(arbre)
si !est_feuille(arbre)
échange_cyclique_gauche(arbre.enfant)
pour i de 0 à 3
rotation_gauche(arbre.enfant[i])
```
![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
# Rotation d'un quart de cercle
# Un petit exercice
\footnotesize
* Insérer les nœuds suivants dans un arbre AVL
## Comment faire sur un arbre?
```
25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40
| 50 | 55 | 30 | 15
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 31 | 27
9 | 7 | 4 | 4 4 | 4 | 0 | 3
----------------- => -----------------
1 | 1 | 0 | 31 12 | 7 | 1 | 1
1 | 1 | 3 | 27 21 | 9 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
```
* Écrire le vrai code (5min, matrix)
. . .
```C
void rotate(node *qt) {
if (!is_leaf(qt)) {
node *tmp = qt->child[2];
qt->child[2] = qt->child[0];
qt->child[0] = qt->child[1];
qt->child[1] = qt->child[3];
qt->child[3] = tmp;
for (int i=0; i<CHILDREN; i++) {
rotate(qt->child[i]);
}
}
}
```
# Compression sans perte (1/5)
## Idée générale
* Regrouper les pixels par valeur
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 21 | 12 | 4
9 | 7 | 4 | 4 9 | 7 |
----------------- => -----------------
1 | 1 | 0 | 31 1 | 0 | 31
1 | 1 | 3 | 27 | 3 | 27
IG=2 | ID=3 IG=2 | ID=3
```
* Comment faire?
# Compression sans perte (2/5)
## Que devient l'arbre suivant?
![](figs/quad_img_simple.svg)
. . .
```
## Arbre compressé
![](figs/quad_img_simple_comp.svg)
# Suppression dans un arbre AVL
# Compression sans perte (3/5)
* Si un nœud a tous ses enfants égaux:
* Stocker cette valeur dans ce nœud,
* Supprimer ses enfants.
* Jusqu'à remonter à la racine.
::: columns
## Écrire le pseudo-code (5min, matrix)
:::: 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
. . .
```C
rien compression_sans_perte(arbre)
si !est_feuille(arbre)
pour i de 0 à 3
compression_sans_perte(arbre.enfant[i])
si derniere_branche(arbre)
valeur, toutes_égales = valeur_enfants(arbre)
si toutes_egales
arbre.info = valeur
detruire_enfants(arbre)
```
::::
# Compression sans perte (4/5)
:::: column
\footnotesize
## Écrire le code C (5min, matrix)
. . .
## 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
```C
void lossless_compression(node *qt) {
if (!is_leaf(qt)) {
for (int i=0; i<CHILDREN; i++) {
lossless_compression(qt->child[i]);
}
if (is_last_branch(qt)) {
int val = -1;
if (last_value(qt, &val)) {
qt->info = val;
for (int i=0; i<CHILDREN; ++i) {
free(qt->child[i]);
qt->child[i] = NULL;
}
}
}
}
}
```
::::
# Compression sans perte (5/5)
:::
\footnotesize
# Suppression dans un arbre AVL
```C
bool is_last_branch(node *qt) {
for (int i = 0; i < CHILDREN; ++i) {
if (!is_leaf(qt)) {
return false;
}
}
return true;
}
bool last_value(node *qt, int *val) {
int info = qt->child[0];
for (int i = 1; i < CHILDREN; ++i) {
if (info != qt->child[i]) {
return false;
}
}
*val = info;
return true;
}
```
::: columns
# Compression avec perte (1/5)
## Idée générale
:::: 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
* Regrouper les pixels par valeur sous certaines conditions
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 3 21 | 12 | 4
9 | 7 | 4 | 4 9 | 7 |
----------------- => ------------------
1 | 1 | 0 | 31 1 | 0 | 31
2 | 1 | 3 | 27 | 3 | 27
IG=2 | ID=3 IG=2 | ID=3
```
::::
* On enlève si l'écart à la moyenne est "petit"?
:::: column
# Compression avec perte (2/5)
. . .
## Que devient l'arbre suivant si l'écart est petit?
## 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
```
![](figs/quad_img_simple_variation.svg)
::::
. . .
:::
## Arbre compressé
# Suppression dans un arbre AVL
![](figs/quad_img_simple_comp_loss.svg)
::: columns
# Compression avec perte (3/5)
:::: 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
```
## Comment mesurer l'écart à la moyenne?
::::
. . .
* Avec l'écart-type
\begin{equation*}
\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{4}\sum_{i=0}^3 (\mu-p[i])
^2} = \sqrt{\frac{1}{4}\left(\sum_{i=0}^3p[i]^2\right)-\mu^2}
\end{equation*}
:::: column
## Que devient l'algorithme?
. . .
1. On supprime comme d'habitude.
2. On rééquilibre si besoin à l'endroit de la suppression.
* Si $\sigma<\theta$, où $\theta$ est la **tolérance**:
* Remplacer la valeur du pixel par la moyenne des enfants.
* Remonter les valeurs dans l'arbre.
* Facile non?
## Quelle influence de la valeur de $\theta$ sur la compression?
. . .
* Plus dur....
* Plus $\theta$ est grand, plus l'image sera compressée.
::::
# Compression avec perte (4/5)
:::
## Que devient l'arbre avec $\theta=0.5$?
# Suppression dans un arbre AVL 2.0
![L'arbre original.](figs/quad_img_simple_variation.svg)
::: 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
```
![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)
::::
# Compression avec perte (5/5)
:::: column
## Modifications sur la structure de données?
. . .
## 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
* On stocke la moyenne, et la moyenne des carrés.
```C
struct noeud
flottant moyenne, moyenne_carre
node enfants[4]
```
::::
* Comment on calcule `moyenne` et `moyenne_carre` sur chaque nœud (pseudo-code)?
:::
# Calcul de la moyenne
# Suppression dans un arbre AVL 2.0
## Pseudo-code (5min, matrix)
::: 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
```C
rien moyenne(arbre) {
si !est_feuille(arbre)
pour enfant dans arbre.enfants
moyenne(enfant)
pour enfant dans arbre.enfants
arbre.moyenne += enfant.moyenne
arbre.moyenne_carre += enfant.moyenne_carre
arbre.moyenne /= 4
arbre.moyenne_carre /= 4
```
::::
# La compression avec pertes
:::: column
\footnotesize
## Pseudo-code (5min, matrix)
. . .
## 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
```C
rien compression_avec_pertes(arbre, theta)
si !est_feuille(arbre)
pour i de 0 à 3
compression_avec_pertes(arbre.enfant[i])
si derniere_branche(arbre)
si racine(arbre.moyenne_carre - arbre.moyenne^2) < theta
detruire_enfants(arbre)
```
::::
## Le code en entier
:::
```C
arbre = matrice_à_arbre(matrice)
moyenne(arbre)
compression_avec_pertes(arbre)
```
# Résumé de la suppression
# La dynamique des corps célestes
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 peut déséquilibrer un autre nœud.
3. On continue à rééquilibrer tant qu'il y a des nœuds à équilibrer.
## Slides très fortement inspirés du cours de J. Latt, Unige
## Simulation du problème à $N$-corps
# Les arbres quaternaires
* Prédiction du mouvement d'un grand nombre de corps célestes.
* Modélisation:
* On se limite aux étoiles;
* Chaque étoile est caractérisée par un point (coordonnées) et une masse;
* On simule en deux dimensions.
* Interactions uniquement par les lois de la gravitation Newtonienne (oui-oui c'est de la **physique**!).
\Huge Les arbres quaternaires
# Les équations du mouvement
# Les arbres quaternaires
## Mouvement de la $i$-ème étoile
## Définition
* Algorithme de Verlet ($t_{n+1}=t_n+\delta t$)
Arbre dont chaque nœud a 4 enfants ou aucun.
$$
\vec x_i(t_{n+1})= 2\vec x_i(t_n)-\vec x_i(t_{n-1})+\vec a_i(t_n)\delta t^2.
$$
![Un exemple d'arbre quaternaire.](figs/quad_ex.svg)
## Force de gravitation
# Les arbres quaternaires
* $\vec a_i(t_n)=\vec F_i/m_i$.
* Sur l'étoile $i$, la force résultante est donnée par
## Cas d'utilisation
$$
\vec F_i=\sum_{j=1,j\neq i}^N \vec F_{ij}.
$$
avec
$$
\vec F_{ij}=\frac{G m_i m_j(\vec x_j-\vec x_i)}{||\vec x_j-\vec x_i||^3}.
$$
Typiquement utilisés pour représenter des données bidimensionnelles.
# Algorithme du problème à $n$-corps
Son équivalent tri-dimensionnel est l'octree (chaque nœud a 8 enfants ou aucun).
## Pseudo-code: structure de données
## Cas d'utilisation: images
```C
struct étoile
flottant m
vec x, x_precedent, f
```
* Stockage: compression.
* Transformations: symétries, rotations, etc.
## Pseudo-code: itération temporelle
## Cas d'utilisation: simulation
```C
rien iteration_temporelle(étoiles, dt)
pour étoile_une dans étoiles
étoile_une.f = 0
pour étoile_deux dans étoiles
si (étoile_un != étoile_deux)
étoile_une.f +=
force(étoile_une, étoile_deux)
pour étoile dans étoiles
étoile.x, étoile.x_precedent =
verlet(étoile.x, étoile.x_precedent,
étoile.f / étoile.m, dt)
```
* Indexation spatiale.
* Détection de collisions.
* Simulation de galaxies, Barnes-Hut.
# Algorithme du problème à $n$-corps
# Exemple de compression
## Complexité
::: columns
* Complexité de chacune des parties?
:::: {.column width=30%}
. . .
## Comment représenter l'image
* $\mathcal{O}(N^2)$, $\mathcal{O}(N)$.
![Image noir/blanc.](figs/board_blacked_parts.svg)
## En temps CPU pour **une itération**
::::
\footnotesize
:::: {.column width=70%}
* Si le temps pour $N=1$ est environ $1\mu s$, on a:
## Sous la forme d'un arbre quaternaire?
+--------+-------+-------+-----------+
| N | N^2 | t [s] | t [réel] |
+--------+-------+-------+-----------+
| 10 | 10^2 | 1e-4 | |
+--------+-------+-------+-----------+
| 10^4 | 10^8 | 1e+2 | ~1min |
+--------+-------+-------+-----------+
| 10^6 | 10^12 | 1e+6 | ~11j |
+--------+-------+-------+-----------+
| 10^9 | 10^18 | 1e+12 | ~30K ans |
+--------+-------+-------+-----------+
| 10^11 | 10^22 | 1e+16 | ~300M ans |
+--------+-------+-------+-----------+
. . .
* Typiquement, il y a des milliers-millions d'itérations.
* Il y a $10^{11}$ étoiles dans la galaxie.
* Houston we have a problem.
![L'arbre quaternaire correspondant.](figs/quad_img.svg)
# Question
**Économie?**
## Comment faire mieux? Des idées?
. . .
Image 64 pixels, arbre 25 nœuds.
* Si un groupe d'étoiles est suffisamment loin, on le modélise comme un corps unique situé en son centre de masse.
* Exemple: Si on simule plusieurs galaxies, on considère chaque galaxie comme un corps unique!
* Un arbre quaternaire est une structure parfaite pour regrouper les étoiles.
# Le cas à 10 corps
::: columns
:::: {.column width=50%}
## Illustration: le cas à 10 corps
![](figs/nbody_bare.png){width=60%}
::::
:::: {.column width=50%}
## Problématique
* On veut calculer la force sur $1$.
::::
:::
. . .
# Structure de données
::: columns
:::: {.column width=50%}
## Pseudo-code?
## Illustration: le cas à 10 corps
. . .
![](figs/nbody_n2.png){width=60%}
```python
struct node
info
node sup_gauche, sup_droit,
inf_gauche, inf_droit
```
![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
::::
:::: {.column width=50%}
## Résultat
* Calcul et somme des forces venant des $9$ autre corps.
::::
:::
# Le cas à 10 corps
::: columns
:::: {.column width=50%}
## En C?
## Réduction d'un groupe à un seul corps
. . .
![](figs/nbody_group.png){width=100%}
```C
struct _node {
int info;
struct _node *sup_left;
struct _node *sup_right;
struct _node *inf_left;
struct _node *inf_right;
};
```
::::
* Pourquoi le `*` est important?
:::: {.column width=50%}
. . .
## Idée
* Type récursif => taille inconnue à la compilation.
* On accélère le calcul en traitant un groupe comme un seul corps.
* Fonctionne uniquement si le groupe est assez loin.
* Autrement l'approximation est trop grossière.
::::
:::
# Une fonctionnalité simple
# Solution: l'arbre quaternaire
\footnotesize
## Corps célestes - arbre
## La fonction `est_feuille(noeud)`
![](figs/nbody_qt_withtree.png)
* Problème avec cette implémentation?
* On omet les nœuds vides pour alléger la représentation.
* La numérotation est:
* 0: ID
* 1: SD
* 2: IG
* 3: SG
```python
bool est_feuille(noeud)
retourne
est_vide(sup_gauche(noeud)) &&
est_vide(sup_droit(noeud)) &&
est_vide(inf_gauche(noeud)) &&
est_vide(inf_droit(noeud))
```
# Exemple d'insertion
. . .
::: columns
* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
* Facile d'en oublier un!
* Comment changer la structure pour que ça soit moins terrible?
:::: {.column width=50%}
. . .
## Insertion corps 1
```python
struct node
info
node enfant[4]
```
![](figs/corps1.png){width=100%}
# Structure de données
::::
## En C?
:::: {.column width=50%}
. . .
## Arbre, niveau 1
```C
typedef struct _node {
int info;
struct _node *child[4];
} node;
```
![](figs/arbre1.png){width=100%}
## Fonction `is_leaf(node *tree)`?
* Quadrant ID.
* La feuille est vide, on insère.
. . .
::::
```C
bool is_leaf(node *tree) {
return (NULL == tree->child[0]); // only first matters
}
```
:::
# Problème à résoudre
# Exemple d'insertion
* Construire un arbre quaternaire à partir d'une image:
* Créer l'arbre (allouer la mémoire pour tous les nœuds),
* Le remplir avec les valeurs des pixels.
* Compression de l'image:
* Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
* Si les pixels dévient pas trop on supprime le quadrant (avec perte)
::: columns
# Création de l'arbre
:::: {.column width=50%}
## Comment créer un arbre de profondeur `prof` (3min)?
## Insertion corps 2
. . .
![](figs/corps2.png){width=100%}
```python
arbre creer_arbre(prof)
n = nouveau_noeud() # alloue la mémoire
si prof > 0
pour i = 0 à 3
n.enfant[i] = creer_arbre(prof-1)
retourne n
```
::::
## En `C` (3 min, matrix)?
:::: {.column width=50%}
. . .
## Arbre, niveau 1
```C
node *qt_create(int depth) {
node *n = calloc(1, sizeof(node));
if (depth > 0) {
for (int i = 0; i < 4; ++i) {
n->child[i] = qt_create(depth-1);
}
}
return n;
}
```
![](figs/arbre2.png){width=100%}
# Le nombre de nœuds?
* Quadrant SD.
* La feuille est vide, on insère.
## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
::::
. . .
:::
```C
entier nombre_nœuds(arbre)
si est_feuille(arbre)
retourne 1
sinon
somme = 1
pour i de 0 à 3
somme += nombre_nœuds(arbre.enfant[i])
retourne somme
```
# Exemple d'insertion
# Le nombre de nœuds?
::: columns
## Comment implémenter la fonction en C (3min, matrix)?
:::: {.column width=50%}
. . .
## Insertion corps 3 (1/N)
```C
int size(node *qt) {
if (is_leaf(qt)) {
return 1;
} else {
int sum = 1;
for (int i = 0; i < 4; ++i) {
sum += size(qt->child[i]);
}
return sum;
}
}
```
![](figs/corps3_1.png){width=100%}
# La profondeur en C?
::::
## Implémentation (5min, matrix)
:::: {.column width=50%}
. . .
## Arbre, niveau 1
\footnotesize
![](figs/arbre3_1.png){width=100%}
```C
int max(int x, int y) {
return (x >= y ? x : y);
}
int max_depth(int depths[4]) {
int m = depths[0];
for (int i = 1; i < 4; ++i) {
m = max(m, depths[i]);
}
return m;
}
int depth(node *qt) {
int depths[] = {0, 0, 0, 0};
if (is_leaf(qt)) {
return 0;
} else {
for (int i = 0; i < 4; ++i) {
depths[i] = depth(qt->child[i]);
}
return 1 + max_depth(depths);
}
}
```
* Quadrant SD.
* La feuille est prise par 2.
# Fonctions utiles (1/4)
::::
## Comment remplir un arbre depuis une matrice?
:::
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
# Exemple d'insertion
## Quel arbre cela représente?
::: columns
. . .
:::: {.column width=50%}
![L'arbre correspondant](figs/quad_img_simple.svg)
## Insertion corps 3 (2/N)
# Fonctions utiles (2/4)
![](figs/corps3_2.png){width=100%}
* On veut transformer une ligne/colonne en feuille.
* Comment?
::::
::: columns
:::: {.column width=50%}
:::: {.column width=40%}
## Arbre, niveau 2
## Soit `ligne=2`, `colonne=3`
![](figs/arbre3_2.png){width=100%}
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
* On crée un nouveau nœud.
* Deux corps dans le nœud ID.
* On crée un nouveau nœud.
::::
:::: {.column width=70%}
:::
# Exemple d'insertion
## Trouver un algorithme
::: columns
![Déterminer un algorithme.](figs/quad_img_simple.svg)
:::: {.column width=50%}
* Quelle feuille pour 31 (`li=2`, `co=3`)?
* Plus important: quel chemin?
## Insertion corps 3 (3/N)
. . .
![](figs/corps3_3.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 3
![](figs/arbre3_3.png){width=100%}
* `co -> G/D`, `li -> S/I`,
* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
* Comment généraliser?
* 2 va dans ID.
* 3 va dans SG.
* C'est des feuilles vides, tout va bien.
::::
:::
# Fonctions utiles (3/4)
# Exemple d'insertion
::: columns
:::: {.column width=40%}
:::: {.column width=50%}
## Soit `ligne=2`, `colonne=3`
## Que fait-on avec les nœuds intérieurs?
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
* On les utilise pour:
* stocker la masse totale;
* stocker le centre de masse.
\begin{align}
m&=m_2+m_3,\\
\vec x &= \frac{m_2\vec x_2+m_3\vec x_3}{m}.
\end{align}
## Chaque feuille contient **une étoile**
::::
:::: {.column width=70%}
:::: {.column width=50%}
## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
## Arbre
![Déterminer un algorithme.](figs/quad_img_simple.svg)
![](figs/arbre3_3.png){width=100%}
* Comment généraliser?
::::
. . .
:::
# Résumé
* Insertion du corps `c` dans le nœud `n` en partant de la racine.
* Si le nœud `n`
* ne contient pas de corps, on y dépose `c`;
* est interne, on met à jour masse et centre de masse, `c` est inséré récursivement dans le bon quadrant;
* est externe, on subdivise `n`, on met à jour la masse et centre de masse, on insère récursivement les deux nœuds dans les quadrants appropriés.
## Remarque
* Il faut stocker les coordonnées des quadrants.
* Un nœud a un comportement différent s'il est interne ou externe.
# Algorithme d'insertion
## Structure de données
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
struct node
etoile e // externe: pour stocker
etoile sup_etoile // interne: pour stocker m, x
quadrant q // coordonnées du quadrant
node enfants[4]
```
## Remarque:
::::
:::
* On fait une simplification "moche": `sup_etoile` pourrait juste avoir une masse et une position.
# Fonctions utiles (4/4)
# Algorithme d'insertion
\footnotesize
## Pseudo-code
## Algorithme d'insertion, pseudo-code (15min, matrix)
. . .
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
rien insertion_etoile(arbre, e)
si (!est_vide(arbre) && dans_le_quadrant(arbre.q, e.x)) {
si (est_feuille(arbre))
si (!contient_etoile(arbre))
arbre.e = e
sinon
// on crée enfants et arbre.sup_etoile est initialisée
subdivision_arbre(arbre, e)
pour enfant dans arbre.enfants
insertion_etoile(enfant, arbre.e)
pour enfant dans arbre.enfants
insertion_etoile(enfant, e)
destruction(arbre.e)
sinon
maj_masse_cdm(arbre.sup_etoile, e)
pour enfant dans arbre.enfants
insertion_etoile(enfant, e)
```
## Écrire le code `C` correspondant (5min, matrix)
# Utilisation de l'arbre
```C
* L'arbre est rempli: comment on calcule la force sur le corps 1?
* Parcours de l'arbre:
* Si la distance entre 1 et le centre de masse est suffisante, on utilise la masse totale et centre de masse pour calculer la force.
* Sinon on continue le parcours.
# Calcul de la force
## Calcul de la force sur `1`
![](figs/force_1.png)
* Le cadrant ID ne contient que `1`, rien à faire.
# Calcul de la force
## Calcul de la force sur `1`
![](figs/force_2.png)
* Le cadrant SG contient `5` corps.
# Calcul de la force
## Calcul de la force sur `1`
```
![](figs/force_3.png)
# Remplir l'arbre
* La distance entre `1` et le centre de masse de SG est `d`.
## A partir d'une matrice (pseudo-code, 5min, matrix)?
# Calcul de la force
. . .
## Calcul de la force sur `1`
```C
arbre matrice_à_arbre(matrice)
arbre = creer_arbre(profondeur)
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
noeud.info = matrice[co][li]
retourne arbre
```
![](figs/force_4.png)
. . .
* La distance entre `1` et le centre de masse de SG est `d`.
* Est-ce que `d` est assez grand?
* On va comparer avec la distance `d` avec la taille du quadrant `s`.
## A partir d'une matrice (C, 5min, matrix)?
# Critère $\theta$
. . .
* On compare $d=||\vec x_1-\vec x_{cm}||$ avec $s$ la taille du quadrant.
* Le domaine est assez éloigné si
\footnotesize
$$
\frac{s}{d}<\theta,
$$
* $\theta$ est la valeur de seuil.
* Une valeur typique est $\theta=0.5$, donc la condition devient
```C
node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth)
{
node *qt = qt_create(depth);
for (int li = 0; li < nd_li; ++li) {
for (int co = 0; co < nd_co; ++co) {
node *current = position(li, co, qt);
current->info = matrix[li][co];
}
}
return qt;
}
```
$$
d>2s.
$$
# Calcul de la force
# Remplir la matrice
## Calcul de la force sur `1`
## A partir de l'arbre (pseudo-code, 3min, matrix)?
![](figs/force_4.png)
. . .
* Ici $d<2s$, domaine rejeté.
* On descend dans l'arbre.
```C
matrice arbre_à_matrice(arbre)
matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
matrice[co][li] = noeud.info
retourne matrice
```
# Calcul de la force
. . .
## Calcul de la force sur `1`
![](figs/force_5.png)
## A partir de l'arbre (C, 3min, matrix)?
* `s` est plus petit, mais....
* Cela ne suffit pas $d<2s$, domaine rejeté.
# Calcul de la force
## Calcul de la force sur `1`
![](figs/force_6.png)
* Les nœuds sont des feuilles, on calcule la force.
* On ajoute la force qu'ils exercent sur `1`.
# Algorithme pour le calcul de la force
Pour calculer la force sur un corps `c`, on parcourt l'arbre en commençant par la racine:
* Si le nœud `n` est une feuille et n'est pas `c`, on ajoute la force dûe à `n` sur `c`;
* Sinon, si $s/d<\theta$, on traite `n` comme une feuille et on ajoute la force dûe à `n` sur `c`;
* Sinon on continue sur les enfants récursivement.
## Continuons notre exemple précédent!
# Calcul de la force
## Calcul de la force sur `1`
![](figs/force_7.png)
* Il y a deux corps dans le quadrant vert.
* Quel est le critère pour remplacer les étoiles par leur centre de masse?
. . .
* Et oui! $d>2s$, donc on peut remplacer les étoiles par leur centre de masse!
# Algorithme du calcul de force
## Écrire le pseudo-code-code du calcul de la force
\footnotesize
```C
void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co])
for (int li = 0; li < nd_li; ++li) {
for (int co = 0; co < nd_co; ++co) {
node *current = position(li, co, qt);
matrix[li][co] = current->info;
}
}
rien maj_force_sur_etoile(arbre, e, theta)
si est_vide(arbre)
retourne
si est_feuille(arbre) && contient_etoile(arbre)
&& dans_le_quadrant(arbre.q, e.x)
maj_force(e, arbre.e)
sinon si noeud_assez_loin(arbre, e, theta)
maj_force(e, arbre.sup_etoile)
sinon
pour enfant dans enfants
maj_force_sur_etoile(enfant, e, theta)
```
slides/cours_21.md
View file @ febfc3f8
---
title: "Arbres quaternaires"
date: "2024-04-25"
title: "Les B-arbres"
date: "2025-04-11"
---
# Les arbres quaternaires
# Les B-arbres
\Huge Les arbres quaternaires
\Huge
Les B-arbres
# Les arbres quaternaires
## Définition
# Les B-arbres
Arbre dont chaque nœud a 4 enfants ou aucun.
![Un exemple d'arbre quaternaire.](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.
## Problématique
# Exemple de compression
* Grands jeux de données (en 1970).
* Stockage dans un arbre, mais l'arbre ne tient pas en mémoire.
* Regrouper les sous-arbres en **pages** qui tiennent en mémoire.
::: columns
## Exemple
:::: {.column width=30%}
* 100 nœuds par page et l'arbre comporte $10^6$ nœuds:
* 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}$.
## Comment représenter l'image
## Remarques
![Image noir/blanc.](figs/board_blacked_parts.svg)
* On ne sait pas ce que veut dire `B`: Bayer, Boeing, Balanced?
* Variante plus récente B+-arbres.
::::
# Les B-arbres
:::: {.column width=70%}
## Illustration, arbre divisé en pages de 3 nœuds
## Sous la forme d'un arbre quaternaire?
![Arbre divisé en pages de 3 nœuds](figs/barbres_page3.png)
. . .
![L'arbre quaternaire correspondant.](figs/quad_img.svg)
## Utilisation
**Économie?**
* Bases de données (souvent très grandes donc sur le disque);
* Systèmes de fichiers.
. . .
# Les B-arbres
Image 64 pixels, arbre 25 nœuds.
## Avantages
::::
* Arbres moins profonds;
* Diminution des opérations de rééquilibrage;
* Complexité toujours en $\log(N)$;
:::
. . .
## Définition: B-arbre d'ordre $n$
# Structure de données
* 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.
::: columns
# Les B-arbres
:::: {.column width=50%}
## Est-ce un B-arbre?
## Pseudo-code?
![B-arbre d'ordre 2.](figs/barbres_exemple.png)
. . .
```python
struct node
info
node sup_gauche, sup_droit,
inf_gauche, inf_droit
```
![Un nœud d'arbre quaternaire.](figs/quad_struct.svg)
## Oui!
::::
* Dans chaque nœud les clés sont **triées**.
* Chaque page contient au plus $n$ nœuds: check;
* Chaque nœud avec $m$ clés a $m+1$ descendants;
* Toutes les feuilles apparaissent au même niveau.
:::: {.column width=50%}
# Les B-arbres
## En C?
## Exemple de recherche: trouver `32`
![B-arbre d'ordre 2.](figs/barbres_exemple.png)
. . .
```C
struct _node {
int info;
struct _node *sup_left;
struct _node *sup_right;
struct _node *inf_left;
struct _node *inf_right;
};
```
* Si `C` plus petit que la 1ère clé ou plus grand que la dernière descendre.
* Sinon parcourir (par bissection ou séquentiellement) jusqu'à trouver où descendre entre 2 éléments.
* Pourquoi le `*` est important?
# Les B-arbres
. . .
## Algorithme de recherche de la clé `C`
* Type récursif => taille inconnue à la compilation.
0. En partant de la racine.
1. Si on est dans une feuille:
* Si `C` est dans la page, retourner la page;
* Sinon c'est perdu.
2. Sinon:
* Tant que `C < clé(page)` passer à la clé suivante
* Si `C` est dans la page, retourner la page;
* Sinon descendre
::::
# Les B-arbres
:::
## Disclaimer
# Une fonctionnalité simple
* Inspiration de <https://en.wikipedia.org/wiki/B-tree>
\footnotesize
## La fonction `est_feuille(noeud)`
* Problème avec cette implémentation?
```python
bool est_feuille(noeud)
retourne
est_vide(sup_gauche(noeud)) &&
est_vide(sup_droit(noeud)) &&
est_vide(inf_gauche(noeud)) &&
est_vide(inf_droit(noeud))
```
## Exemples d'insertion: `1`
![B-arbre d'ordre 1.](figs/barbres_1.svg)
. . .
* Inutile d'avoir 4 conditions (soit 4 enfants soit aucun!)
* Facile d'en oublier un!
* Comment changer la structure pour que ça soit moins terrible?
* L'arbre est vide, on insère juste dans la première page.
. . .
```python
struct node
info
node enfant[4]
```
# Les B-arbres
# Structure de données
## En C?
## Exemples d'insertion: `2`
![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_2.svg)
. . .
```C
typedef struct _node {
int info;
struct _node *child[4];
} node;
```
* La première page n'est pas pleine, on insère dans l'ordre (après 1).
## Fonction `is_leaf(node *tree)`?
# Les B-arbres
. . .
## Exemples d'insertion: `3`
```C
bool is_leaf(node *tree) {
return (NULL == tree->child[0]); // only first matters
}
```
# Problème à résoudre
![B-arbre d'ordre 1.](figs/barbres_2.svg){width=50%}
* Construire un arbre quaternaire à partir d'une image:
* Créer l'arbre (allouer la mémoire pour tous les nœuds),
* Le remplir avec les valeurs des pixels.
* Compression de l'image:
* Si les pixels sont les mêmes dans le quadrant on supprime le sous-arbre (sans perte)
* Si les pixels dévient pas trop on supprime le quadrant (avec perte)
* Comment on insère (1min de réflexion avant de donner une réponse!)?
# Création de l'arbre
# Les B-arbres
## Comment créer un arbre de profondeur `prof` (3min)?
## Exemples d'insertion: `3`
![B-arbre d'ordre 1. Nombre pages max = 2.](figs/barbres_3.svg){width=50%}
. . .
```python
arbre creer_arbre(prof)
n = nouveau_noeud() # alloue la mémoire
si prof > 0
pour i = 0 à 3
n.enfant[i] = creer_arbre(prof-1)
retourne n
```
* 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.
## En `C` (3 min, matrix)?
# Les B-arbres
. . .
## Exemples d'insertion: `4`
```C
node *qt_create(int depth) {
node *n = calloc(1, sizeof(node));
if (depth > 0) {
for (int i = 0; i < 4; ++i) {
n->child[i] = qt_create(depth-1);
}
}
return n;
}
```
![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!)?
# Le nombre de nœuds?
# Les B-arbres
## Comment implémenter la fonction (pseudo-code, 5min, matrix)?
## Exemples d'insertion: `4`
![B-arbre d'ordre 1. Nombre enfants 0 ou 2.](figs/barbres_4.svg){width=50%}
. . .
```C
entier nombre_nœuds(arbre)
si est_feuille(arbre)
retourne 1
sinon
somme = 1
pour i de 0 à 3
somme += nombre_nœuds(arbre.enfant[i])
retourne somme
```
# Le nombre de nœuds?
* 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`.
## Comment implémenter la fonction en C (3min, matrix)?
# Les B-arbres
. . .
## Exemples d'insertion: `5`
```C
int size(node *qt) {
if (is_leaf(qt)) {
return 1;
} else {
int sum = 1;
for (int i = 0; i < 4; ++i) {
sum += size(qt->child[i]);
}
return sum;
}
}
```
![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!)?
# La profondeur en C?
# Les B-arbres
## Implémentation (5min, matrix)
## Exemples d'insertion: `5`
![B-arbre d'ordre 1.](figs/barbres_5.svg)
. . .
\footnotesize
* On descend à droite (on ne 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 nœud à droite de `4`;
* La règle `m => m+1` est ok.
```C
int max(int x, int y) {
return (x >= y ? x : y);
}
int max_depth(int depths[4]) {
int m = depths[0];
for (int i = 1; i < 4; ++i) {
m = max(m, depths[i]);
}
return m;
}
int depth(node *qt) {
int depths[] = {0, 0, 0, 0};
if (is_leaf(qt)) {
return 0;
} else {
for (int i = 0; i < 4; ++i) {
depths[i] = depth(qt->child[i]);
}
return 1 + max_depth(depths);
}
}
```
# Les B-arbres
# Fonctions utiles (1/4)
## Exemples d'insertion: `6`
## Comment remplir un arbre depuis une matrice?
![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!)?
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
# Les B-arbres
## Quel arbre cela représente?
## Exemples d'insertion: `6`
![B-arbre d'ordre 1.](figs/barbres_6.svg)
. . .
![L'arbre correspondant](figs/quad_img_simple.svg)
# Fonctions utiles (2/4)
* On veut transformer une ligne/colonne en feuille.
* Comment?
::: columns
:::: {.column width=40%}
## Soit `ligne=2`, `colonne=3`
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
* `6 > 4` on descend à droite;
* `6 > 5` et on a à la place à droite, on insère.
::::
# Les B-arbres
:::: {.column width=70%}
## Exemples d'insertion: `7`
## Trouver un algorithme
![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!)?
![Déterminer un algorithme.](figs/quad_img_simple.svg)
# Les B-arbres
* Quelle feuille pour 31 (`li=2`, `co=3`)?
* Plus important: quel chemin?
## Exemples d'insertion: `7`
![B-arbre d'ordre 1.](figs/barbres_7.svg){width=50%}
. . .
* `co -> G/D`, `li -> S/I`,
* `2 * (li / 2) + co / 2 -> 2 * 1 + 1 = 3`
* `2 * ((li % 2) / 1) + (co % 2) / 1 -> 2 * 0 + 1 = 1`
* Comment généraliser?
* `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
# Fonctions utiles (3/4)
0. Rechercher la feuille (la page n'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.
::: columns
# Les B-arbres
:::: {.column width=40%}
## Exercice: insérer `22, 45, 50` dans l'arbre d'ordre 2 (3min matrix)
## Soit `ligne=2`, `colonne=3`
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
```
::::
:::: {.column width=70%}
## Trouver un algorithme (prendre plusieurs exemples, 15min, matrix)
![Déterminer un algorithme.](figs/quad_img_simple.svg)
* Comment généraliser?
![](figs/barbres_ex1.png)
. . .
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
```
::::
:::
# Fonctions utiles (4/4)
\footnotesize
## Pseudo-code
```C
noeud position(li, co, arbre)
d = profondeur(arbre);
tant_que (d >= 1)
index = 2 * ((li % 2^d) / 2^(d-1)) +
(col % 2^d) / 2^(d-1)
arbre = arbre.enfant[index]
d -= 1
retourne arbre
```
## Écrire le code `C` correspondant (5min, matrix)
```C
![](figs/barbres_ex2.png)
```
# Les B-arbres
# Remplir l'arbre
## Exercice: insérer `5` dans l'arbre d'ordre 2 (3min matrix)
## A partir d'une matrice (pseudo-code, 5min, matrix)?
![](figs/barbres_ex2.png)
. . .
```C
arbre matrice_à_arbre(matrice)
arbre = creer_arbre(profondeur)
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
noeud.info = matrice[co][li]
retourne arbre
```
![](figs/barbres_ex3.png)
. . .
# Les B-arbres
## A partir d'une matrice (C, 5min, matrix)?
## Exercice: insérer `32, 55, 60` dans l'arbre d'ordre 2 (3min matrix)
. . .
\footnotesize
```C
node *matrix_to_qt(int nb_li, int nb_co, int matrix[nb_li][nb_co], int depth)
{
node *qt = qt_create(depth);
for (int li = 0; li < nd_li; ++li) {
for (int co = 0; co < nd_co; ++co) {
node *current = position(li, co, qt);
current->info = matrix[li][co];
}
}
return qt;
}
```
![](figs/barbres_ex3.png)
. . .
# Remplir la matrice
![](figs/barbres_ex4.png)
## A partir de l'arbre (pseudo-code, 3min, matrix)?
# Les B-arbres
. . .
## Exercice: insérer `41` dans l'arbre d'ordre 2 (3min matrix)
```C
matrice arbre_à_matrice(arbre)
matrice = creer_matrice(nb_lignes(arbre), nb_colonnes(arbre))
pour li de 0 à nb_lignes(matrice)
pour co de 0 à nb_colonnes(matrice)
noeud = position(li, co, arbre)
matrice[co][li] = noeud.info
retourne matrice
```
![](figs/barbres_ex4.png)
. . .
## A partir de l'arbre (C, 3min, matrix)?
![](figs/barbres_ex5.png)
. . .
# Les B-arbres
\footnotesize
## Exercice (matrix, 15min)
```C
void qt_to_matrix(node *qt, int nb_li, int nb_co, int matrix[nb_li][nb_co])
for (int li = 0; li < nd_li; ++li) {
for (int co = 0; co < nd_co; ++co) {
node *current = position(li, co, qt);
matrix[li][co] = current->info;
}
}
```
# Transformations avec un arbre quaternaire
* 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.
## A faire
# Les B-arbres
* Symétrie axiale (horizontale/verticale).
* Rotation quart de cercle (gauche/droite).
* Compression.
\footnotesize
# La symétrie verticale
## Structure de données
## Que donne la symétrie verticale de
* 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;
```
SG=0 | SD=1
21 | 12 | 4 | 4
9 | 7 | 4 | 4
-----------------
1 | 1 | 0 | 31
1 | 1 | 3 | 27
IG=2 | ID=3
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?
```
SG=0 | SD=1
4 | 4 | 12 | 21
4 | 4 | 7 | 9
------------------
31 | 0 | 1 | 1
27 | 3 | 1 | 1
IG=2 | ID=3
```
# La symétrie d'axe vertical
# Les B-arbres
## Comment faire sur une matrice (3min, matrix)?
## Faire un dessin de la structure de données (3min matrix)?
. . .
\footnotesize
```C
matrice symétrie(matrice)
pour i de 0 à nb_colonnes(matrice) / 2
pour j de 0 à nb_lignes(matrice)
échanger(matrice[i][j], matrice[nb_colonnes(matrice)-1-i][j])
retourne matrice
```
![Structure d'une page de B-arbre d'ordre 2.](figs/barbres_struct.png)
# La symétrie d'axe vertical
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.
## Comment faire sur un arbre?
# Les B-arbres
* Faire un dessin de l'arbre avant/après (5min, matrix)
## L'insertion cas nœud pas plein, insertion `4`?
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 12 | 21
9 | 7 | 4 | 4 4 | 4 | 7 | 9
----------------- => ----------------
1 | 1 | 0 | 31 31 | 0 | 1 | 1
1 | 1 | 3 | 27 27 | 3 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
```
* Écrire le pseudo-code (3min, matrix)
![](figs/barbres_insert_easy.svg){width=50%}
. . .
\footnotesize
```C
arbre symétrie(arbre)
si !est_feuille(arbre)
échanger(arbre.enfant[0], arbre.enfant[1])
échanger(arbre.enfant[2], arbre.enfant[3])
pour i de 0 à 3
symétrie(arbre.enfant[i])
retourne arbre
```
## Solution
# La symétrie d'axe horizontal
![](figs/barbres_insert_easy_after.svg){width=50%}
* Trivial de faire l'axe horizontal (exercice à la maison)
# Les B-arbres
# Rotation d'un quart de cercle
## L'insertion cas nœud pas plein, insertion `N`
## Comment faire sur un arbre?
* 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é.
* Faire un dessin de l'arbre avant/après (5min, matrix)
# Les B-arbres
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 31 | 27
9 | 7 | 4 | 4 4 | 4 | 0 | 3
----------------- => -----------------
1 | 1 | 0 | 31 12 | 7 | 1 | 1
1 | 1 | 3 | 27 21 | 9 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
## L'insertion cas nœud plein, insertion `2`?
```
* Écrire le pseudo-code (3min, matrix)
![](figs/barbres_insert_hard_before.svg){width=50%}
. . .
```C
rien rotation_gauche(arbre)
si !est_feuille(arbre)
échange_cyclique_gauche(arbre.enfant)
pour i de 0 à 3
rotation_gauche(arbre.enfant[i])
```
## Solution
# Rotation d'un quart de cercle
\footnotesize
![](figs/barbres_insert_hard_during.svg){width=50%}
## Comment faire sur un arbre?
# Les B-arbres
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 4 | 4 | 31 | 27
9 | 7 | 4 | 4 4 | 4 | 0 | 3
----------------- => -----------------
1 | 1 | 0 | 31 12 | 7 | 1 | 1
1 | 1 | 3 | 27 21 | 9 | 1 | 1
IG=2 | ID=3 IG=2 | ID=3
```
## L'insertion cas nœud plein, promotion `3`?
* Écrire le vrai (5min, matrix)
![](figs/barbres_insert_hard_during.svg){width=50%}
. . .
```C
void rotate(node *qt) {
if (!is_leaf(qt)) {
node *tmp = qt->child[2];
qt->child[2] = qt->child[0];
qt->child[0] = qt->child[1];
qt->child[1] = qt->child[3];
qt->child[3] = tmp;
for (int i=0;i < 4; i++) {
rotate(qt->child[i]);
}
}
}
```
# Compression sans perte (1/5)
## Solution
## Idée générale
![](figs/barbres_insert_hard_after.svg)
* Regrouper les pixels par valeur
# Les B-arbres
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 4 21 | 12 | 4
9 | 7 | 4 | 4 9 | 7 |
----------------- => -----------------
1 | 1 | 0 | 31 1 | 0 | 31
1 | 1 | 3 | 27 | 3 | 27
IG=2 | ID=3 IG=2 | ID=3
```
* Comment faire?
# Compression sans perte (2/5)
## Que devient l'arbre suivant?
![](figs/quad_img_simple.svg)
## 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 valeurs à 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.
## Arbre compressé
# Les B-arbres
![](figs/quad_img_simple_comp.svg)
# Compression sans perte (3/5)
* Si un nœud a tous ses enfants égaux:
* Donner la valeur au nœud,
* Supprimer les enfants.
* Remonter jusqu'à la racine.
## Écrire le pseudo-code (5min, matrix)
## Pseudo-code structure de données (3min, matrix)?
. . .
```C
rien compression_sans_pertes(arbre)
si !est_feuille(arbre)
pour i de 0 à 3
compression_sans_pertes(arbre.enfant[i])
si derniere_branche(arbre)
valeur, toutes_égales = valeur_enfants(arbre)
si toutes_egales
arbre.info = valeur
detruire_enfants(arbre)
struct page
entier ordre, nb
element tab[2*ordre + 2]
```
# Compression sans perte (4/5)
\footnotesize
## Écrire le code C (5min, matrix)
. . .
```C
void lossless_compression(node *qt) {
if (!is_leaf(qt)) {
for (int i = 0; i < CHILDREN; i++) {
lossless_compression(qt->child[i]);
}
if (is_last_branch(qt)) {
int val = -1;
if (last_value(qt, &val)) {
qt->info = val;
for (int i = 0; i < 4; ++i) {
free(qt->child[i]);
qt->child[i] = NULL;
}
}
}
}
}
struct element
entier clé
page pg
```
# Compression sans perte (5/5)
# Les B-arbres
\footnotesize
```C
bool is_last_branch(node *qt) {
for (int i = 0; i < 4; ++i) {
if (!is_leaf(qt)) {
return false;
}
}
return true;
}
bool last_value(node *qt, int *val) {
int info = qt->child[0];
for (int i = 1; i < 4; ++i) {
if (info != qt->child[i]) {
return false;
}
}
*val = info;
return true;
}
```
## Les fonctions utilitaires (5min matrix)
# Compression avec perte (1/5)
## Idée générale
* Regrouper les pixels par valeur sous certaines conditions
```
SG=0 | SD=1 SG=0 | SD=1
21 | 12 | 4 | 3 21 | 12 | 4
9 | 7 | 4 | 4 9 | 7 |
----------------- => ------------------
1 | 1 | 0 | 31 1 | 0 | 31
2 | 1 | 3 | 27 | 3 | 27
IG=2 | ID=3 IG=2 | ID=3
```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
```
* On enlève si l'écart à la moyenne est "petit"?
# Compression avec perte (2/5)
## Que devient l'arbre suivant si l'écart est petit?
![](figs/quad_img_simple_variation.svg)
. . .
## Arbre compressé
![](figs/quad_img_simple_comp_loss.svg)
# Compression avec perte (3/5)
## Comment mesurer l'écart à la moyenne?
. . .
* Avec l'écart-type
\begin{equation*}
\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{4}\sum_{i=0}^3 (\mu-p[i])
^2} = \sqrt{\frac{1}{4}\left(\sum_{i=0}^3p[i]^2\right)-\mu^2}
\end{equation*}
## Que devient l'algorithme?
. . .
* Si $\sigma<\theta$, $\theta$ est la **tolérance**:
* Remplacer la valeur du pixel par la moyenne des enfants.
* Remonter les valeurs dans l'arbre.
## Quelle influence de la valeur de $\theta$ sur la compression?
. . .
* Plus $\theta$ est grand, plus l'image sera compressée.
# Compression avec perte (4/5)
## Que devient l'arbre avec $\theta=0.5$?
![L'arbre original.](figs/quad_img_simple_variation.svg)
. . .
![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)
# Compression avec perte (5/5)
## Modifications sur la structure de données?
. . .
* On stocke la moyenne, et la moyenne des carrés.
```C
struct noeud
flottant moyenne, moyenne_carre
node enfants[4]
```
booléen est_feuille(page)
retourne (page.tab[0].pg == vide)
* Comment on calcule `moyenne` et `moyenne_carre` sur chaque nœud (pseudo-code)?
entier position(page, valeur)
i = 0
tant que i < page.nb && valeur >= page.tab[i+1].clef
i += 1
retourne i
# Calcul de la moyenne
## Pseudo-code (5min, matrix)
. . .
```C
rien moyenne(arbre) {
si !est_feuille(arbre)
pour enfant dans arbre.enfants
moyenne(enfant)
pour enfant dans arbre.enfants
arbre.moyenne += enfant.moyenne
arbre.moyenne_carre += enfant.moyenne_carre
arbre.moyenne /= 4
arbre.moyenne_carre /= 4
booléen est_dans_page(page, valeur)
i = position(page, valeur)
retourne (page.nb > 0 && page.tab[i].val == valeur)
```
# La compression avec pertes
# Les B-arbres
\footnotesize
## Pseudo-code (5min, matrix)
. . .
## Les fonctions utilitaires (5min matrix)
```C
rien compression_avec_pertes(arbre, theta)
si !est_feuille(arbre)
pour i de 0 à 3
compression_avec_pertes(arbre.enfant[i])
si derniere_branche(arbre)
si racine(arbre.moyenne_carre - arbre.moyenne^2) < theta
detruire_enfants(arbre)
page nouvelle_page(ordre) // créer une page
rien liberer_memoire(page) // libérer tout un arbre!
```
## Le code en entier
. . .
```C
arbre = matrice_à_arbre(matrice)
moyenne(arbre)
compression_avec_pertes(arbre)
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)
```
# La dynamique des corps célestes
## Slides très fortement inspirés du cours de J. Latt, Unige
# Les B-arbres
## Simulation du problème à $N$-corps
* Prédiction du mouvement d'un grand nombre de corps célestes.
* Modélisation:
* On se limite aux étoiles;
* Chaque étoile est caractérisée par un point (coordonnées) et une masse;
* On simule en deux dimensions.
* Interactions uniquement par les lois de la gravitation Newtonienne (oui-oui c'est de la **physique**!).
# Les équations du mouvement
## Mouvement de la $i$-ème étoile
* Algorithme de Verlet ($t_{n+1}=t_n+\delta t$)
$$
\vec x_i(t_{n+1})= 2\vec x_i(t_n)-\vec x_i(t_{n-1})+\vec a_i(t_n)\delta t^2.
$$
## Force de gravitation
* $\vec a_i(t_n)=\vec F_i/m_i$.
* Sur l'étoile $i$, la force résultante est donnée par
$$
\vec F_i=\sum_{j=1,j\neq i}^N \vec F_{ij}.
$$
avec
$$
\vec F_{ij}=\frac{G m_i m_j(\vec x_j-\vec x_i)}{||\vec x_j-\vec x_i||^3}.
$$
# Algorithme du problème à $n$-corps
## Pseudo-code: structure de données
## Les fonctions (5min matrix)
```C
struct étoile
flottant m
vec x, x_precedent, f
page recherche(page, valeur) // retourner la page contenant
// la valeur ou vide
```
## Pseudo-code: itération temporelle
. . .
```C
rien iteration_temporelle(étoiles, dt)
pour étoile_une dans étoiles
étoile_une.f = 0
pour étoile_deux dans étoiles
si (étoile_un != étoile_deux)
étoile_une.f +=
force(étoile_une, étoile_deux)
pour étoile dans étoiles
étoile.x, étoile.x_precedent =
verlet(étoile.x, étoile.x_precedent,
étoile.f / étoile.m, dt)
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)
```
# Algorithme du problème à $n$-corps
## Complexité
* Complexité de chacune des parties?
. . .
* $\mathcal{O}(N^2)$, $\mathcal{O}(N)$.
## En temps CPU pour **une itération**
\footnotesize
* Si temps pour $N=1$ on calcule en $1\mu s$:
+--------+-------+-------+-----------+
| N | N^2 | t [s] | t [réel] |
+--------+-------+-------+-----------+
| 10 | 10^2 | 1e-4 | |
+--------+-------+-------+-----------+
| 10^4 | 10^8 | 1e+2 | ~1min |
+--------+-------+-------+-----------+
| 10^6 | 10^12 | 1e+6 | ~11j |
+--------+-------+-------+-----------+
| 10^9 | 10^18 | 1e+12 | ~30k ans |
+--------+-------+-------+-----------+
| 10^11 | 10^22 | 1e+16 | ~300M ans |
+--------+-------+-------+-----------+
* Typiquement il y a des milliers-millions d'itérations.
* Il y a $10^{11}$ étoiles dans la galaxie.
* Houston we have a problem.
# Question
## Comment faire mieux, des idées?
. . .
* Si un groupe d'étoiles est suffisamment loin, on le modélise comme un corps unique situé en son centre de masse.
* Exemple: Si on simule plusieurs galaxies, on considère chaque galaxie comme un corps unique!
* Un arbre quaternaire est une structure parfaite pour regrouper les étoiles.
# Le cas à 10 corps
::: columns
:::: {.column width=50%}
## Illustration: le cas à 10 corps
![](figs/nbody_bare.png){width=60%}
::::
:::: {.column width=50%}
## Problématique
* On veut calculer la force sur $1$.
::::
:::
. . .
::: columns
:::: {.column width=50%}
## Illustration: le cas à 10 corps
![](figs/nbody_n2.png){width=60%}
::::
:::: {.column width=50%}
## Résultat
* Calcul et somme des forces venant des $9$ autre corps.
::::
:::
# Le cas à 10 corps
::: columns
:::: {.column width=50%}
## Réduction d'un groupe à un seul corps
![](figs/nbody_group.png){width=100%}
::::
:::: {.column width=50%}
## Idée
* On accélère le calcul en traitant un groupe comme un seul corps.
* Fonctionne uniquement si le groupe est assez loin.
* Autrement l'approximation est trop grossière.
::::
:::
# Solution: l'arbre quaternaire
## Corps célestes - arbre
![](figs/nbody_qt_withtree.png)
* On omet les nœuds vides pour éviter la surcharge.
* La numérotation est:
* 0: ID
* 1: SD
* 2: IG
* 3: SG
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Insertion corps 1
![](figs/corps1.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 1
![](figs/arbre1.png){width=100%}
* Quadrant ID.
* La feuille est vide, on insère.
::::
:::
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Insertion corps 2
![](figs/corps2.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 1
![](figs/arbre2.png){width=100%}
* Quadrant SD.
* La feuille est vide, on insère.
::::
:::
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Insertion corps 3 (1/N)
![](figs/corps3_1.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 1
![](figs/arbre3_1.png){width=100%}
* Quadrant SD.
* La feuille est prise par 2.
::::
:::
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Insertion corps 3 (2/N)
![](figs/corps3_2.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 2
![](figs/arbre3_2.png){width=100%}
* On crée un nouveau nœud.
* Deux corps dans le nœud ID.
* On crée un nouveau nœud.
::::
:::
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Insertion corps 3 (3/N)
![](figs/corps3_3.png){width=100%}
::::
:::: {.column width=50%}
## Arbre, niveau 3
![](figs/arbre3_3.png){width=100%}
* 2 va dans ID.
* 3 va dans SG.
* C'est des feuilles vides, tout va bien.
::::
:::
# Exemple d'insertion
::: columns
:::: {.column width=50%}
## Que fait-on avec les nœuds intérieurs?
* On les utilise pour:
* stocker la masse totale;
* stocker le centre de masse.
\begin{align}
m&=m_2+m_3,\\
\vec x &= \frac{m_2\vec x_2+m_3\vec x_3}{m}.
\end{align}
## Chaque feuille contient **une étoile**
::::
:::: {.column width=50%}
## Arbre
![](figs/arbre3_3.png){width=100%}
::::
:::
# Résumé
* Insertion du corps `c` dans le nœud `n` en partant de la racine.
* Si le nœud `n`
* ne contient pas de corps, on y dépose `c`,
* est interne, on met à jour masse et centre de masse. `c` est inséré récursivement dans le bon quadrant.
* est externe, on subdivise `n`, on met à jour la masse et centre de masse, on insère récursivement les deux nœuds dans les quadrants appropriés.
## Remarque
* Il faut stocker les coordonnées des quadrants.
* Un nœud a un comportement différent s'il est interne ou externe.
slides/cours_22.md 0 → 100644
View file @ febfc3f8
---
title: "Les B-arbres"
date: "2025-05-09"
---
# Les B-arbres (rappel)
## 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 (rappel)
## Est-ce un B-arbre?
![B-arbre d'ordre 2.](figs/barbres_exemple.png)
. . .
### Bien sûr!
# Les B-arbres (rappel)
## 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 (rappel)
## 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 (rappel)
## 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";
* Comme la page ne déborde pas, on a terminé.
# Les B-arbres (rappel)
## 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 (rappel)
## 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 (rappel)
## L'insertion cas nœud plein, insertion `N`
* On décale les éléments plus grands 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 valeurs à 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 (rappel)
## Pseudo-code structure de données
. . .
```C
struct page
entier ordre, nb
element tab[2*ordre + 2]
```
```C
struct element
entier clé
page pg
```
# Les B-arbres (rappel)
\footnotesize
## Les fonctions utilitaires (5min matrix)
```C
booléen est_feuille(page) // la page est-elle une feuille?
entier position(page, valeur) // à quelle indice insère-t-on?
booléen est_dans_page(page, valeur) // la valeur est-elle 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 (rappel)
\footnotesize
## Les fonctions utilitaires
```C
page nouvelle_page(ordre) // créer une page
```
. . .
```C
page nouvelle_page(ordre)
page = allouer(page)
page.ordre = ordre
page.nb = 0
page.tab = allouer(2*ordre+2)
retourner page
```
# Les B-arbres (rappel)
## Recherche de page
```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 (nouveautés)
## 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 element
```
. . .
```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; -->
<!-- ``` -->
# 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=50%}
. . .
* 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=50%}
. . .
* Un élément à droite, comment on fait?
* Remonter `7`, serait ok si racine, mais... ce n'est pas forcément le cas.
* On redistribue les feuilles.
. . .
![Descente de `3`, remontée médiane des feuilles `2`.](figs/barbres_ordre2_supp5.svg){width=50%}
# Les B-arbres: suppression
\footnotesize
## Cas ultra moins simple
![Suppression de 3.](figs/barbres_ordre2_supp6.svg){width=60%}
. . .
* `7` seul:
* Fusionner les feuilles et redistribuer, comment?
. . .
![Descendre `-1`, déplacer `7` à gauche, et décaler les éléments de droite au milieu.](figs/barbres_ordre2_supp7.svg){width=60%}
# Les B-arbres: suppression
## Cas ultra moins simple
![On a pas fini...](figs/barbres_ordre2_supp7.svg){width=60%}
. . .
* `8` est seul, ce n'est plus un B-arbre :
* Fusionner le niveau 2 et redistribuer, comment?
. . .
![Fusionner `8`, `17`, `22` et descendre `12`.](figs/barbres_ordre2_supp8.svg){width=40%}
. . .
* La profondeur a diminué de 1.
# Les B-arbres: suppression
## Algorithme pour les feuilles!
* Si la clé est supprimée d'une feuille:
* Si on a toujours `n` (ordre de l'arbre) clés dans la feuille, on décale simplement les clés.
* Sinon on combine (récursivement) avec le nœud voisin et on descend la clé médiane.
# Les B-arbres: suppression
## Cas non-feuille!
![Suppression de 8.](figs/barbres_ordre2_supp9.svg){width=60%}
. . .
* On sait comment effacer une valeur d'une feuille, donc?
. . .
![Échanger le `8` avec le plus grand du sous-arbre de gauche.](figs/barbres_ordre2_supp10.svg){width=60%}
* Ensuite?
# Les B-arbres: suppression
## Cas non-feuille!
![Suppression de 8.](figs/barbres_ordre2_supp10.svg){width=60%}
. . .
* On sait comment effacer une valeur d'une feuille!
. . .
![Yaka enlever le 8 de la feuille comme avant!](figs/barbres_ordre2_supp11.svg){width=60%}
# Les B-arbres: suppression
## Algorithme pour les non-feuilles!
* Si la clé est supprimée d'une page qui n'est pas une feuille:
* On échange la valeur avec la valeur de droite de la page de gauche.
* On supprime comme pour une feuille!
## Et maintenant des exercices par millions!
slides/cours_23.md 0 → 100644
View file @ febfc3f8
---
title: "Théorie des graphes"
date: "2025-05-16"
---
# Les graphes
\Huge
Les graphes
# Les graphes! Historique
**Un mini-peu d'histoire...**
## L. Euler et les 7 ponts de Koenigsberg:
* Existe-t-il une promenade sympa, passant **une seule fois** par les 7 ponts et revenant au point de départ?
![Les ponts, c'est beau. Source: Wikipédia, <https://bit.ly/37h0yOG>](figs/Konigsberg_bridges.png){width=40%}
. . .
* Réponse: ben non!
# Utilisation quotidienne
## Réseau social
![Source: Wikipedia, <https://bit.ly/3kG6cgo>](figs/Social_Network.svg){width=40%}
* Chaque sommet est un individu.
* Chaque trait une relation d'amitié.
* Miam, Miam, Facebook.
# Utilisation quotidienne
## Moteurs de recherche
![Source: Wikipedia, <https://bit.ly/3kG6cgo>](figs/PageRanks-Example.svg){width=40%}
* Site est un sommet.
* Liens sortants.
* Liens entrants.
* Notion d'importance d'un site: combien de liens entrants, pondérés par l'importance du site.
* Miam, Miam, Google (PageRank).
# Introduction
## Définition, plus ou moins
* Un graphe est un ensemble de sommets, reliés par des lignes ou des flèches.
![Deux exemples de graphes.](figs/ex_graphes.png)
* Des sommets (numérotés 1 à 6);
* Connectés ou pas par des traits ou des flèches!
# Généralités
## Définitions
* Un **graphe** $G(V, E)$ est constitué
* $V$: un ensemble de sommets;
* $E$: un ensemble d'arêtes.
* Une **arête** relie une **paire** de sommets de $V$.
## Remarques
* Il y a **au plus** une arête $E$ par paire de sommets de $V$.
* La **complexité** d'un algorithme dans un graphe se mesure en terme de $|E|$ et $|V|$, le nombre d'éléments de $E$ et $V$ respectivement.
# Généralités
## Notations
* Une arête d'un graphe **non-orienté** est représentée par une paire **non-ordonnée** $(u,v)=(v,u)$, avec $u,v\in V$.
* Les arêtes ne sont pas orientées dans un graphe non-orienté
(elles sont bi-directionnelles, c.-à-d. peuvent être parcourues dans n'importe quel sens).
## Exemple
::: columns
:::: column
![Un graphe non-orienté.](figs/ex_graphe_non_oriente.svg)
::::
:::: column
## Que valent $V$, $|V|$, $E$, et $|E|$?
. . .
\begin{align*}
V&=\{1, 2, 3, 4\},\\
|V|&=4,\\
E&=\{(1,2),(2,3),(2,4),(4,1)\},\\
|E|&=4.
\end{align*}
::::
:::
# Généralités
## Notations
* Une arête d'un graphe **orienté** est représentée par une paire **ordonnée** $(u,v)\neq(v,u)$, avec $u,v\in V$.
* Les arêtes sont orientées dans un graphe orienté (étonnant non?).
## Exemple
::: columns
:::: column
![Un graphe orienté.](figs/ex_graphe_oriente.svg)
::::
:::: column
## Que valent $V$, $|V|$, $E$, et $|E|$?
. . .
\begin{align*}
V&=\{1, 2, 3, 4\},\\
|V|&=4,\\
E&=\{(1,2),(2,3),(2,4),(4,1),(4,2)\},\\
|E|&=5.
\end{align*}
::::
:::
# Généralités
## Définition
* Le somme $v$ est **adjacent** au sommet $u$, si et seulement si $(u,v)\in E$;
* Si un graphe non-orienté contient une arête $(u,v)$, $v$ est adjacent à $u$ et $u$ est adjacent à $v$.
## Exemple
::: columns
:::: column
![Sommet $a$ adjacent à $c$, $c$ adjacent à $a$.](figs/ex_adj_non_or.svg){width=60%}
::::
:::: column
![Sommet $c$ adjacent à $a$.](figs/ex_adj_or.svg){width=60%}
::::
:::
# Généralités
## Définition
* Un **graphe pondéré** ou **valué** est un graphe dont chaque arête a un
poids associé, habituellement donné par une fonction de pondération $w:E\rightarrow\mathbb{R}$.
## Exemples
![Graphe pondéré orienté (gauche) et non-orienté (droite).](figs/ex_graph_pond.pdf){width=80%}
# Généralités
## Définition
* Dans un graphe $G(V,E)$, une **chaîne** reliant un sommet $u$ à un sommet $v$ est une suite d'arêtes entre les sommets, $w_0$, $w_1$, ..., $w_k$, telles que
$$
(w_i, w_{i+1})\in E,\quad u=w_0,\quad v=w_k,\quad \mbox{pour }0\leq i< k,
$$
avec $k$ la longueur de la chaîne (le nombre d'arêtes du chemin).
## Exemples
![Illustration d'une chaîne dans un graphe.](figs/ex_graphe_chaine.pdf){width=80%}
# Généralités
## Définition
* Une **chaîne élémentaire** est une chaîne dont tous les sommets sont distincts, sauf les extrémités qui peuvent être égales.
## Exemples
![Illustration d'une chaîne élémentaire dans un graphe.](figs/ex_graphe_chaine_elem.pdf){width=80%}
# Généralités
## Définition
* Une **boucle** est une arête $(v,v)$ d'un sommet vers lui-même.
## Exemples
![Illustration d'une boucle dans un graphe.](figs/ex_graphe_boucle.pdf){width=40%}
# Généralités
## Définition
* Un graphe non-orienté est dit **connexe**, s'il existe un chemin reliant n'importe quelle paire de sommets distincts.
## Exemples
\
::: columns
:::: column
![Graphe connexe. Source: Wikipédia, <https://bit.ly/3yiUzUv>](figs/graphe_connexe.svg){width=60%}
::::
:::: column
![Graphe non-connexe avec composantes connexes. Source: Wikipédia, <https://bit.ly/3KJB76d>](figs/composantes_connexes.svg){width=40%}
::::
:::
# Généralités
## Définition
* Un graphe orienté est dit **fortement connexe**, s'il existe un chemin reliant n'importe quelle paire de sommets distincts.
## Exemples
\
::: columns
:::: column
![Graphe fortement connexe.](figs/ex_graph_fort_connexe.pdf){width=60%}
::::
:::: column
![Composantes fortement connexes. Source, Wikipédia: <https://bit.ly/3w5PL2l>](figs/composantes_fortement_connexes.svg){width=100%}
::::
:::
# Généralités
## Définition
* Un **cycle** dans un graphe *non-orienté* est une chaîne de longueur $\geq 3$ telle que le 1er sommet de la chaîne est le même que le dernier, et dont les arêtes sont distinctes.
* Pour un graphe *orienté*, on parle de **circuit**.
* Un graphe sans cycles est dit **acyclique**.
## Exemples
![Illustration de cycles.](figs/ex_graphe_cycle.pdf){width=100%}
# Question de la mort
* Qu'est-ce qu'un graphe connexe acyclique?
. . .
* Un arbre!
# Représentations
* La complexité des algorithmes sur les graphes s'expriment en fonction du nombre de sommets $V$, et du nombre d'arêtes $E$:
* Si $|E|\sim |V|^2$, on dit que le graphe est **dense**.
* Si $|E|\sim |V|$, on dit que le graphe est **peu dense**.
* Selon qu'on considère des graphes denses ou peu denses, différentes structures de données peuvent être envisagées.
## Question
* Comment peut-on représenter un graphe informatiquement? Des idées (réflexion de quelques minutes)?
. . .
* Matrice/liste d'adjacence.
# Matrice d'adjacence
* Soit le graphe $G(V,E)$, avec $V=\{1, 2, 3, ..., n\}$;
* On peut représenter un graphe par une **matrice d'adjacence**, $A$, de dimension $n\times n$ définie par
$$
A_{ij}=\left\{ \begin{array}{ll}
1 & \mbox{si } i,j\in E,\\
0 & \mbox{sinon}.
\end{array} \right.
$$
::: columns
:::: column
## Exemple
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---4;
2---5;
4---5;
5---3;
```
::::
:::: column
\footnotesize
## Quelle matrice d'adjacence?
. . .
```
|| 1 | 2 | 3 | 4 | 5
===||===|===|===|===|===
1 || 0 | 1 | 0 | 1 | 0
---||---|---|---|---|---
2 || 1 | 0 | 0 | 0 | 1
---||---|---|---|---|---
3 || 0 | 0 | 0 | 0 | 1
---||---|---|---|---|---
4 || 1 | 0 | 0 | 0 | 1
---||---|---|---|---|---
5 || 0 | 1 | 1 | 1 | 0
```
::::
:::
# Matrice d'adjacence
## Remarques
* Zéro sur la diagonale.
* La matrice d'un graphe non-orienté est symétrique
$$
A_{ij}=A_{ji}, \forall i,j\in[1,n]
$$.
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---4;
2---5;
4---5;
5---3;
```
::::
:::: column
\footnotesize
```
|| 1 | 2 | 3 | 4 | 5
===||===|===|===|===|===
1 || 0 | 1 | 0 | 1 | 0
---||---|---|---|---|---
2 || 1 | 0 | 0 | 0 | 1
---||---|---|---|---|---
3 || 0 | 0 | 0 | 0 | 1
---||---|---|---|---|---
4 || 1 | 0 | 0 | 0 | 1
---||---|---|---|---|---
5 || 0 | 1 | 1 | 1 | 0
```
::::
:::
# Matrice d'adjacence
* Pour un graphe orienté (digraphe)
::: columns
:::: column
## Exemple
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
2-->1;
1-->4;
2-->5;
5-->2;
4-->5;
5-->3;
```
::::
:::: column
\footnotesize
## Quelle matrice d'adjacence?
. . .
```
|| 1 | 2 | 3 | 4 | 5
===||===|===|===|===|===
1 || 0 | 0 | 0 | 1 | 0
---||---|---|---|---|---
2 || 1 | 0 | 0 | 0 | 1
---||---|---|---|---|---
3 || 0 | 0 | 0 | 0 | 0
---||---|---|---|---|---
4 || 0 | 0 | 0 | 0 | 1
---||---|---|---|---|---
5 || 0 | 1 | 1 | 0 | 0
```
::::
:::
* La matrice d'adjacence n'est plus forcément symétrique
$$
A_{ij}\neq A_{ji}.
$$
# Stockage
* Quel est l'espace nécessaire pour stocker une matrice d'adjacence pour un graphe orienté?
. . .
* $\mathcal{O}(|V|^2)$
* Quel est l'espace nécessaire pour stocker une matrice d'adjacence pour un graphe non-orienté?
. . .
* $\mathcal{O}\left((|V|-1)|V|/2\right)$.
# Considérations d'efficacité
* Dans quel type de graphes la matrice d'adjacence est-elle utile?
. . .
* Dans les graphes denses.
* Pourquoi?
. . .
* Dans les graphes peu denses, la matrice d'adjacence est essentiellement composée de `0`.
## Remarque
* Dans la majorité des cas, les grands graphes sont peu denses.
* Comment représenter un graphe autrement?
# La liste d'adjacence (non-orienté)
* Pour chaque sommet $v\in V$, stocker les sommets adjacents à $v$.
* Quelle structure de données pour la liste d'adjacence?
. . .
* Tableau de liste chaînée, vecteur (tableau dynamique), etc.
::: columns
:::: column
## Exemple
![Un graphe non-orienté.](figs/ex_graph_adj.pdf){width=80%}
::::
:::: column
## Quelle liste d'adjacence?
. . .
![La liste d'adjacence.](figs/ex_graph_list_adj.pdf)
::::
:::
# La liste d'adjacence (orienté)
::: columns
:::: column
## Quelle liste d'adjacence pour...
* Matrix (2min)
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
0-->1;
0-->2;
1-->2;
3-->0;
3-->1;
3-->2;
```
::::
:::: column
```
```
::::
:::
# Complexité
## Stockage
* Quelle espace est nécessaire pour stocker une liste d'adjacence (en fonction de $|E|$ et $|V|$)?
. . .
$$
\mathcal{O}(|V|+|E|)
$$
* Pour les graphes *non-orientés*: $\mathcal{O}(|V|+2|E|)$.
* Pour les graphes *orientés*: $\mathcal{O}(|V|+|E|)$.
## Définition
* Le **degré** d'un sommet $v$, est le nombre d'arêtes incidentes du sommet (pour les graphes orientés on a un degré entrant ou sortant).
* Comment retrouve-t-on le degré de chaque sommet avec la liste d'adjacence?
. . .
* C'est la longueur de la liste chaînée si le graphe est non-orienté.
# Parcours
* Beaucoup d'applications nécessitent de parcourir des graphes:
* trouver un chemin d'un sommet à un autre;
* trouver si le graphe est connexe.
* Il existe *deux* parcours principaux:
* en largeur (Breadth-First Search);
* en profondeur (Depth-First Search).
* Ces parcours créent *un arbre* au fil de l'exploration (si le graphe est non-connexe, cela crée une *forêt*, c.-à-d. un ensemble d'arbres).
# Illustration: parcours en largeur
![Le parcours en largeur.](figs/parcours_larg.pdf){width=80%}
# Exemple
## Étape par étape (blanc non-visité)
![Initialisation.](figs/parcours_larg_0.pdf){width=50%}
## Étape par étape (gris visité)
![On commence en `x`.](figs/parcours_larg_1.pdf){width=50%}
# Exemple
## Étape par étape
![On commence en `x`.](figs/parcours_larg_1.pdf){width=50%}
## Étape par étape (vert à visiter)
![Visiter `w`, `t`, `y`.](figs/parcours_larg_2.pdf){width=50%}
# Exemple
## Étape par étape
![Visiter `w`, `t`, `y`.](figs/parcours_larg_2.pdf){width=50%}
## Étape par étape
![`w`, `t`, `y` visités. `u`, `s` à visiter.](figs/parcours_larg_3.pdf){width=50%}
# Exemple
## Étape par étape
![`w`, `t`, `y` visités. `u`, `s` à visiter.](figs/parcours_larg_3.pdf){width=50%}
## Étape par étape
![`u`, `s`, visités. `r` à visiter.](figs/parcours_larg_4.pdf){width=50%}
# Exemple
## Étape par étape
![`u`, `s`, visités. `r` à visiter.](figs/parcours_larg_4.pdf){width=50%}
## Étape par étape
![`r` visité. `v` à visiter.](figs/parcours_larg_5.pdf){width=50%}
# Exemple
## Étape par étape
![`r` visité. `v` à visiter.](figs/parcours_larg_5.pdf){width=50%}
## Étape par étape
![The end. Plus rien à visiter!](figs/parcours_larg_6.pdf){width=50%}
# En faisant ce parcours...
::: columns
:::: column
## Du parcours de l'arbre
![](figs/parcours_larg_6.pdf){width=100%}
::::
:::: column
## Quel arbre est créé par le parcours (2min)?
. . .
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
0[x]-->1[w];
0-->2[t];
0-->3[y];
2-->9[u];
1-->4[s];
4-->5[r];
5-->6[v];
```
::::
:::
## Remarques
* Le parcours dépend du point de départ dans le graphe.
* L'arbre sera différent en fonction du noeud de départ, et de l'ordre de parcours des voisins d'un noeud.
# Le parcours en largeur
## L'algorithme, idée générale (3min, matrix)?
. . .
```C
v = un sommet du graphe
i = 1
pour sommet dans graphe et sommet non-visité
visiter(v, sommet, i) // marquer sommet à distance i visité
i += 1
```
## Remarque
* `i` est la distance de plus court chemin entre `v` et les sommets en cours de visite.
# Le parcours en largeur
## L'algorithme, pseudo-code (3min, matrix)?
* Comment garder la trace de la distance?
. . .
* Utilisation d'une **file d'attente**
. . .
```C
initialiser(graphe) // tous les sommets sont non-visités
visiter(sommet, file) // on choisit un sommet de départ
tant que !est_vide(file)
défiler(file, (v,u))
si u != visité
ajouter (v,u) à arbre T
visiter(u, file)
```
## Que fait visiter?
```
rien visiter(x, file)
marquer x comme visité
pour chaque arête (x,w)
si w != visité
enfiler(file, (x,w))
```
# Exercice (5min)
## Appliquer l'algorithme sur le graphe
![](figs/parcours_larg_0.pdf){width=50%}
* En partant de `v`, `s`, ou `u` (par colonne de classe).
* Bien mettre à chaque étape l'état de la file.
# Complexité du parcours en largeur
## Étape 1
* Extraire un sommet de la file.
## Étape 2
* Traîter tous les sommets adjacents.
## Quelle est la complexité?
. . .
* Étape 1: $\mathcal{O}(|V|)$
* Étape 2: $\mathcal{O}(2|E|)$
* Total: $\mathcal{O}(|V| + |2|E|)$
# Exercice
* Établir la liste d'adjacence et appliquer l'algorithme de parcours en largeur au graphe
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---3;
1---4;
2---3;
2---6;
3---6;
3---4;
3---5;
4---5;
```
# Illustration: parcours en profondeur
![Le parcours en profondeur. À quel parcours d'arbre cela ressemble-t-il?](figs/parcours_prof.pdf){width=80%}
# Parcours en profondeur
## Idée générale
* Initialiser les sommets comme non-lus
* Visiter un sommet
* Pour chaque sommet visité, on visite un sommet adjacent s'il n'est pas encore visité, et ce récursivement.
## Remarque
* La récursivité est équivalent à l'utilisation d'une **pile**.
# Parcours en profondeur
## Pseudo-code (5min)
. . .
```C
initialiser(graphe) // tous les sommets sont non-visités
visiter(sommet, pile) // on choisit un sommet du graphe
tant que !est_vide(pile)
dépiler(pile, (v,u))
si u != visité
ajouter (v,u) à arbre T
visiter(u, pile)
```
## Que fait visiter?
. . .
```C
rien visiter(x, pile)
marquer x comme visité
pour chaque arête (x,w)
si w != visité
empiler(pile, (x,w))
```
# Exercice
* Établir la liste d'adjacence et appliquer l'algorithme de parcours en profondeur au graphe
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---3;
1---4;
2---3;
2---6;
3---6;
3---4;
3---5;
4---5;
```
# Interprétation des parcours
* Un graphe vu comme espace d'états (sommet: état, arête: action)
* Labyrinthe
* Arbre des coups d'un jeu
. . .
* BFS (Breadth-First Search) ou DFS (Depth-First Search) parcourent l'espace des états à la recherche du meilleur mouvement.
* Les deux parcourent *tout* l'espace;
* Mais si l'arbre est grand, l'espace est gigantesque!
. . .
* Quand on a un temps limité
* BFS explore beaucoup de coups dans un futur proche;
* DFS explore peu de coups dans un futur lointain.
slides/cours_24.md 0 → 100644
View file @ febfc3f8
---
title: "Théorie des graphes et plus courts chemins"
date: "2025-05-26"
---
# Les graphes
\Huge
Les graphes
# Exercice
* Établir la liste d'adjacence et appliquer l'algorithme de parcours en largeur au graphe
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---3;
1---4;
2---3;
2---6;
3---6;
3---4;
3---5;
4---5;
```
# Illustration: parcours en profondeur
![Le parcours en profondeur. À quel parcours d'arbre cela ressemble-t-il?](figs/parcours_prof.pdf){width=80%}
# Parcours en profondeur
## Idée générale
* Initialiser les sommets comme non-lus
* Visiter un sommet
* Pour chaque sommet visité, on visite un sommet adjacent s'il n'est pas encore visité, et ce récursivement.
## Remarque
* La récursivité est équivalente à l'utilisation d'une **pile**.
# Parcours en profondeur
## Pseudo-code (5min)
. . .
```C
initialiser(graphe) // tous les sommets sont non-visités
visiter(sommet, pile) // on choisit un sommet du graphe
tant que !est_vide(pile)
dépiler(pile, (v,u))
si u != visité
ajouter (v,u) à arbre T
visiter(u, pile)
```
## Que fait visiter?
. . .
```C
rien visiter(x, pile)
marquer x comme visité
pour chaque arête (x,w)
si w != visité
empiler(pile, (x,w))
```
# Exercice
* Établir la liste d'adjacence et appliquer l'algorithme de parcours en profondeur au graphe
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
1---2;
1---3;
1---4;
2---3;
2---6;
3---6;
3---4;
3---5;
4---5;
```
# Interprétation des parcours
* Un graphe vu comme espace d'états (sommet: état, arête: action);
* Labyrinthe;
* Arbre des coups d'un jeu.
. . .
* BFS (Breadth-First) ou DFS (Depth-First) parcourent l'espace des états à la recherche du meilleur mouvement.
* Les deux parcourent *tout* l'espace;
* Mais si l'arbre est grand, l'espace est gigantesque!
. . .
* Quand on a un temps limité
* BFS explore beaucoup de coups dans un futur proche;
* DFS explore peu de coups dans un futur lointain.
# Algorithmes de plus courts chemins
\Huge Plus courts chemins
# Contexte: les réseaux (informatique, transport, etc.)
* Graphe orienté;
* Source: sommet `s`;
* Destination: sommet `t`;
* Les arêtes ont des poids (coût d'utilisation, distance, etc.);
* Le coût d'un chemin est la somme des poids des arêtes d'un chemin.
## Problème à résoudre
* Quel est le plus court chemin entre `s` et `t`?
# Exemples d'application de plus courts chemins
## Devenir riches!
* On part d'un tableau de taux de change entre devises.
* Quelle est la meilleure façon de convertir l'or en dollar?
![Taux de change.](figs/taux_change.pdf){width=80%}
. . .
* 1kg d'or => 327.25 dollars
* 1kg d'or => 208.1 livres => 327 dollars
* 1kg d'or => 455.2 francs => 304.39 euros => 327.28 dollars
# Exemples d'application de plus courts chemins
## Formulation sous forme d'un graphe: Comment (3min)?
![Taux de change.](figs/taux_change.pdf){width=80%}
# Exemples d'application de plus courts chemins
## Formulation sous forme d'un graphe: Comment (3min)?
![Graphes des taux de change.](figs/taux_change_graphe.pdf){width=60%}
* Un sommet par devise;
* Une arête orientée par transaction possible avec le poids égal au taux de change;
* Trouver le chemin qui maximise le produit des poids.
. . .
## Problème
* On aimerait plutôt avoir une somme...
# Exemples d'application de plus courts chemins
## Conversion du problème en plus courts chemins
* Soit `taux(u, v)` le taux de change entre la devise `u` et `v`.
* On pose `w(u,w)=-log(taux(u,v))`
* Trouver le chemin poids minimal pour les poids `w`.
![Graphe des taux de change avec logs.](figs/taux_change_graphe_log.pdf){width=60%}
* Cette conversion se base sur l'idée que
$$
\log(u\cdot v)=\log(u)+\log(v).
$$
# Applications de plus courts chemins
## Quelles applications voyez-vous?
. . .
* Déplacement d'un robot;
* Planificaiton de trajet / trafic urbain;
* Routage de télécommunications;
* Réseau électrique optimal;
* ...
# Algorithmes de plus courts chemins
\Huge
Algorithmes de plus courts chemins
# Rappel de la problématique
* Graphe orienté;
* Source: sommet `s`;
* Destination: sommet `t`;
* Les arêtes ont des poids (coût d'utilisation, distance, etc.);
* Le coût d'un chemin est la somme des poids des arêtes d'un chemin.
## Problème à résoudre
* Quel est le plus court chemin entre `s` et `t`.
# Plus courts chemins à source unique
* Soit un graphe, $G=(V, E)$, une fonction de pondération $w:E\rightarrow\mathbb{R}$, et un sommet $s\in V$
* Trouver pour tout sommet $v\in V$, le chemin de poids minimal reliant $s$ à $v$.
* Algorithmes standards:
* Dijkstra (arêtes de poids positif seulement);
* Bellman-Ford (arêtes de poids positifs ou négatifs, mais sans cycles négatifs).
* Comment résoudre le problèmes si tous les poids sont les mêmes?
. . .
* Un parcours en largeur!
# Algorithme de Dijkstra
## Comment chercher pour un plus court chemin?
. . .
```
si distance(u,v) > distance(u,w) + distance(w,v)
on passe par w plutôt qu'aller directement
```
# Algorithme de Dijkstra (1 à 5)
* $D$ est le tableau des distances au sommet $1$: $D[7]$ est la distance de 1 à 7.
* Le chemin est pas forcément direct.
* $S$ est le tableau des sommets visités.
::: columns
:::: column
![Initialisation.](figs/dijkstra_0.png)
::::
:::: column
. . .
![1 visité, `D[2]=1`, `D[4]=3`.](figs/dijkstra_1.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est 2.](figs/dijkstra_1.png)
::::
:::: column
. . .
![2 visité, `D[3]=2`, `D[7]=3`.](figs/dijkstra_2.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est 3.](figs/dijkstra_2.png)
::::
:::: column
. . .
![3 visité, `D[7]=3` inchangé, `D[6]=6`.](figs/dijkstra_3.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est 4 ou 7.](figs/dijkstra_3.png)
::::
:::: column
. . .
![4 visité, `D[7]=3` inchangé, `D[5]=9`.](figs/dijkstra_4.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est `7`.](figs/dijkstra_4.png)
::::
:::: column
. . .
![7 visité, `D[5]=7`, `D[6]=6` inchangé.](figs/dijkstra_5.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est 6.](figs/dijkstra_5.png)
::::
:::: column
. . .
![`6` visité, `D[5]=7` inchangé.](figs/dijkstra_6.png)
::::
:::
# Algorithme de Dijkstra (1 à 5)
::: columns
:::: column
![Plus court est 5 et c'est la cible.](figs/dijkstra_6.png)
::::
:::: column
. . .
![The end, tous les sommets ont été visités.](figs/dijkstra_7.png)
::::
:::
# Algorithme de Dijkstra
## Idée générale
* On assigne à chaque noeud une distance $0$ pour $s$, $\infty$ pour les autres.
* Tous les noeuds sont marqués non-visités.
* Depuis le noeud courant, on suit chaque arête du noeud vers un sommet non visité et on calcule le poids du chemin à chaque voisin et on met à jour sa distance si elle est plus petite que la distance du noeud.
* Quand tous les voisins du noeud courant ont été visités, le noeud est mis à visité (il ne sera plus jamais visité).
* Continuer avec le noeud à la distance la plus faible.
* L'algorithme est terminé losrque le noeud de destination est marqué comme visité, ou qu'on n'a plus de noeuds qu'on peut visiter et que leur distance est infinie.
# Algorithme de Dijkstra
## Pseudo-code (5min, matrix)
\footnotesize
. . .
```C
tab dijkstra(graph, s, t)
pour chaque v dans graphe
distance[v] = infini
distance[s] = 0
q = ajouter(q, s) // q est une liste
tant que non_vide(q)
// sélection de u t.q. la distance dans q est min
u = min(q, distance)
si u == t // on a atteint la cible
retourne distance
q = remove(q, u)
// voisin de u encore dans q
pour chaque v dans voisinage(u, q)
// on met à jour la distance du voisin en passant par u
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
retourne distance
```
# Algorithme de Dijkstra
* Cet algorithme, nous donne le plus court chemin mais...
* ne nous donne pas le chemin!
## Comment modifier l'algorithme pour avoir le chemin?
. . .
* Pour chaque nouveau noeud à visiter, il suffit d'enregistrer d'où on est venu!
* On a besoin d'un tableau `precedent`.
## Modifier le pseudo-code ci-dessus pour ce faire (3min matrix)
# Algorithme de Dijkstra
\footnotesize
```C
tab, tab dijkstra(graph, s, t)
pour chaque v dans graphe
distance[v] = infini
precedent[v] = indéfini
distance[s] = 0
q = ajouter(q, s)
tant que non_vide(q)
// sélection de u t.q. la distance dans q est min
u = min(q, distance)
si u == t
retourne distance, precedent
q = remove(q, u)
// voisin de u encore dans q
pour chaque v dans voisinage(u, q)
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
precedent[v] = u
retourne distance, precedent
```
# Algorithme de Dijkstra
## Comment reconstruire un chemin ?
. . .
```C
pile parcours(precedent, s, t)
sommets = vide
u = t
// on a atteint t ou on ne connait pas de chemin
si u != s && precedent[u] != indéfini
tant que vrai
sommets = empiler(sommets, u)
u = precedent[u]
si u == s // la source est atteinte
retourne sommets
retourne sommets
```
# Algorithme de Dijkstra amélioré
## On peut améliorer l'algorithme
* Avec une file de priorité!
## Une file de priorité est
* Une file dont chaque élément possède une priorité,
* Elle existe en deux saveurs: `min` ou `max`:
* File `min`: les éléments les plus petits sont retirés en premier.
* File `max`: les éléments les plus grands sont retirés en premier.
* On regarde l'implémentation de la `max`.
## Comment on fait ça?
. . .
* On insère les éléments à haute priorité tout devant dans la file!
# Les files de priorité
## Trois fonction principales
```C
booléen est_vide(element) // triviale
element enfiler(element, data, priorite)
data defiler(element)
rien changer_priorite(element, data, priorite)
nombre priorite(element) // utilitaire
```
## Pseudo-implémentation: structure (1min)
. . .
```C
struct element
data
priorite
element suivant
```
# Les files de priorité
## Pseudo-implémentation: enfiler (2min)
. . .
```C
element enfiler(element, data, priorite)
n_element = creer_element(data, priorite)
si est_vide(element)
retourne n_element
si priorite(n_element) > priorite(element)
n_element.suivant = element
retourne n_element
sinon
tmp = element
prec = element
tant que !est_vide(tmp)
&& priorite(n_element) < priorite(tmp)
prec = tmp
tmp = tmp.suivant
prec.suivant = n_element
n_element.suivant = tmp
retourne element
```
# Les files de priorité
## Pseudo-implémentation: defiler (2min)
. . .
```C
data, element defiler(element)
si est_vide(element)
retourne AARGL!
sinon
tmp = element.data
n_element = element.suivant
liberer(element)
retourne tmp, n_element
```
# Algorithme de Dijkstra avec file de priorité min
```C
distance, precedent dijkstra(graphe, s, t):
fp = file_p_vide()
distance[s] = 0
pour v dans sommets(graphe)
si v != s
distance[v] = infini
precedent[v] = indéfini
fp = enfiler(fp, v, distance[v])
tant que !est_vide(fp)
u, fp = defiler(fp)
si u == t
retourne distance, precedent
pour v dans voisinage de u
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
precedent[v] = u
fp = changer_priorite(fp, v, n_distance)
retourne distance, precedent
```
# Algorithme de Dijkstra avec file
\footnotesize
```C
distance dijkstra(graphe, s, t)
--------------------O(V*V)--------------------------------
distance[s] = 0
fp = file_p_vide()
pour v dans sommets(graphe) // O(|V|)
si v != s
distance[v] = infini
fp = enfiler(fp, s, distance[s]) // O(|V|)
------------------O(V * V)-------------------------------
tant que !est_vide(fp)
u, fp = defiler(fp) // O(1)
---------------------------------------------------------
pour v dans voisinage de u // O(|E|)
n_distance = distance[u] + w(u, v)
si n_distance < distance[v]
distance[v] = n_distance
fp = changer_priorite(fp, v, n_distance) // O(|V|)
---------------------------------------------------------
retourne distance
```
* Total: $\mathcal{O}(|V|^2+|E|\cdot |V|)$:
* Graphe dense: $\mathcal{O}(|V|^3)$
* Graphe peu dense: $\mathcal{O}(|V|^2)$
# Algorithme de Dijkstra avec file
## On peut faire mieux
* Avec une meilleure implémentation de la file de priorité:
* Tas binaire: $\mathcal{O}(|V|\log|V|+|E|\log|V|)$.
* Tas de Fibonnacci: $\mathcal{O}(|V|+|E|\log|V|)$
* Graphe dense: $\mathcal{O}(|V|^2\log|V|)$.
* Graphe peu dense: $\mathcal{O}(|V|\log|V|)$.
# Algorithme de Dijkstra (exercice, 5min)
![L'exercice.](figs/dijkstra_exo.png){width=60%}
* Donner la liste de priorité, puis...
## A chaque étape donner:
* Le tableau des distances à `a`;
* Le tableau des prédécesseurs;
* L'état de la file de priorité.
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 1.](figs/dijkstra_ex_0.png)
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 2.](figs/dijkstra_ex_1.png)
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 3.](figs/dijkstra_ex_2.png)
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 4.](figs/dijkstra_ex_3.png)
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 5.](figs/dijkstra_ex_4.png)
# Algorithme de Dijkstra (corrigé)
![Le corrigé partie 6.](figs/dijkstra_ex_5.png)
# Limitation de l'algorithme de Dijkstra
## Que se passe-t-il pour?
![Exemple.](figs/exemple_neg.png){width=50%}
## Quel est le problème?
. . .
* L'algorithme n'essaiera jamais le chemin `s->x->y->v` et prendra direct `s->v`.
* Ce problème n'apparaît que s'il y a des poids négatifs.
# Plus cours chemin pour toute paire de sommets
## Comment faire pour avoir toutes les paires?
. . .
* Appliquer Dijkstra sur tous les sommets d'origine.
* Complexité:
* Graphe dense: $\mathcal{O}(|V|)\mathcal{O}(|V|^2\log|V|)=\mathcal{O}(|V|^3\log|V|)$.
* Graphe peu dense: $\mathcal{O}(|V|)\mathcal{O}(|V|\log|V|)=\mathcal{O}(|V|^2\log|V|)$.
. . .
## Solution alternative: Floyd--Warshall
* Pour toutes paires de sommets $u,v\in V$, trouver le chemin de poids minimal reliant $u$ à $v$.
* Complexité $\mathcal{O}(|V|^3)$, indiqué pour graphes denses.
* Fonctionne avec la matrice d'adjacence.
# Algorithme de Floyd--Warshall
## Idée générale
* Soit l'ensemble de sommets $V=\{1, 2, 3, 4, ..., n\}$.
* Pour toute paire de sommets, $i,j$, on considère tous les chemins passant par les sommets intermédiaires $\in\{1, 2, ..., k\}$ avec $k\leq n$.
* On garde pour chaque $k$ la plus petite valeur.
## Principe
* A chaque étape, $k$, on vérifie s'il est plus court d'aller de $i$ à $j$ en passant par le sommet $k$.
* Si à l'étape $k-1$, le coût du parcours est $p$, on vérifie si $p$ est plus petit que $p_1+p_2$, le chemin de $i$ à $k$, et $k$ à $j$ respectivement.
# Algorithme de Floyd--Warshall
## The algorithme
Soit $d_{ij}(k)$ le plus court chemin de $i$ à $j$ passant par les sommets $\in\{1,2,...,k\}$
$$
d_{ij}(k)=\left\{
\begin{array}{ll}
w(i,j), & \mbox{si } k=0,\\
\min(d_{ij}(k-1),d_{ik}(k-1)+d_{kj}(k-1)), & \mbox{sinon}.
\end{array}
\right.
$$
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
![Le graphe, $D=w$.](figs/floyd_exemple.png)
::::
:::: column
## Que vaut $D^{(0)}$ (3min)?
. . .
$$
D^{(0)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 8 & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & \infty & \infty & 0 & 5 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(0)}$?
$$
D^{(0)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 8 & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & \infty & \infty & 0 & 5 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(1)}$ (3min)?
. . .
$$
D^{(1)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & \mathbf{6} & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & \mathbf{3} & \mathbf{5} & 0 & \mathbf{4} \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(0)}$
$$
D^{(0)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 8 & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & \infty & \infty & 0 & 5 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(1)}$ (3min)?
. . .
$$
D^{(1)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & \mathbf{6} & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & \mathbf{3} & \mathbf{5} & 0 & \mathbf{4} \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
## Exemple
$$
D_{42}^{(1)}=D_{41}^{(0)}+D_{12}^{(0)}=1+2<\infty.
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(1)}$
$$
D^{(1)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 6 & \infty & 1 \\
6 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(2)}$ (3min)?
. . .
$$
D^{(2)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 6 & \infty & 1 \\
\mathbf{4} & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(2)}$
$$
D^{(2)}=\begin{bmatrix}
0 & 2 & 4 & \infty & 3 \\
2 & 0 & 6 & \infty & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(3)}$ (3min)?
. . .
$$
D^{(3)}=\begin{bmatrix}
0 & 2 & 4 & \mathbf{8} & 3 \\
2 & 0 & 6 & \mathbf{10} & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(3)}$
$$
D^{(3)}=\begin{bmatrix}
0 & 2 & 4 & 8 & 3 \\
2 & 0 & 6 & 10 & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\infty & \infty & \infty & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(4)}$ (3min)?
. . .
$$
D^{(4)}=\begin{bmatrix}
0 & 2 & 4 & 8 & 3 \\
2 & 0 & 6 & 10 & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
\mathbf{2} & \mathbf{4} & \mathbf{6} & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exemple)
::: columns
:::: column
## On part de $D^{(4)}$
$$
D^{(4)}=\begin{bmatrix}
0 & 2 & 4 & 8 & 3 \\
2 & 0 & 6 & 10 & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
2 & 4 & 6 & 1 & 0 \\
\end{bmatrix}
$$
::::
:::: column
## Que vaut $D^{(5)}$ (3min)?
. . .
$$
D^{(5)}=\begin{bmatrix}
0 & 2 & 4 & \mathbf{4} & 3 \\
2 & 0 & 6 & \mathbf{2} & 1 \\
4 & 2 & 0 & 4 & 3 \\
1 & 3 & 5 & 0 & 4 \\
2 & 4 & 6 & 1 & 0 \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall
## The pseudo-code (10min)
* Quelle structure de données?
* Quelle initialisation?
* Quel est le code pour le calcul de la matrice $D$?
# Algorithme de Floyd--Warshall
## The pseudo-code
* Quelle structure de données?
```C
int distance[n][n];
```
. . .
* Quelle initialisation?
```C
matrice ini_floyd_warshall(distance, n, w)
pour i de 1 à n
pour j de 1 à n
distance[i][j] = w(i,j)
retourne distance
```
# Algorithme de Floyd--Warshall
## The pseudo-code
* Quel est le code pour le calcul de la matrice $D$?
```C
matrice floyd_warshall(distance, n, w)
pour k de 1 à n
pour i de 1 à n
pour j de 1 à n
distance[i][j] = min(distance[i][j],
distance[i][k] + distance[k][j])
retourne distance
```
# Algorithme de Floyd--Warshall
## La matrice de précédence
* On a pas encore vu comment reconstruire le plus court chemin!
* On définit, $P_{ij}^{(k)}$, qui est le prédécesseur du sommet $j$ depuis $i$ avec les sommets intermédiaires $\in\{1, 2, ..., k\}$.
$$
P^{(0)}_{ij}=\left\{
\begin{array}{ll}
\mbox{vide}, & \mbox{si } i=j\mbox{, ou }w(i,j)=\infty\\
i, & \mbox{sinon}.
\end{array}
\right.
$$
* Mise à jour
$$
P^{(k)}_{ij}=\left\{
\begin{array}{ll}
P^{(k-1)}_{\mathbf{i}j}, & \mbox{si } d_{ij}^{(k)}\leq d_{ik}^{(k-1)}+d_{kj}^{(k-1)}\\
P^{(k-1)}_{\mathbf{k}j}, & \mbox{sinon}.
\end{array}
\right.
$$
. . .
* Moralité: si le chemin est plus court en passant par $k$, alors il faut utiliser son prédécesseur!
# Algorithme de Floyd--Warshall
## La matrice de précédence (pseudo-code, 3min)
. . .
```C
matrice, matrice floyd_warshall(distance, n, w)
pour k de 1 à n
pour i de 1 à n
pour j de 1 à n
n_distance = distance[i][k] + distance[k][j]
if n_distance < distance[i][j]
distance[i][j] = n_distance
précédence[i][j] = précédence[k][j]
retourne distance, précédence
```
# Algorithme de Floyd--Warshall (exercice)
::: columns
:::: column
![Le graphe, $D=w$.](figs/floyd_exemple.png)
::::
:::: column
## Que vaut $P^{(0)}$ (3min)?
. . .
$$
P^{(0)}=\begin{bmatrix}
- & 1 & 1 & - & 1 \\
2 & - & 2 & - & 2 \\
3 & 3 & - & 3 & 3 \\
4 & - & - & - & 4 \\
- & - & - & 5 & - \\
\end{bmatrix}
$$
::::
:::
# Algorithme de Floyd--Warshall (exercice)
::: columns
:::: column
![Le graphe, $D=w$.](figs/floyd_exemple.png)
::::
:::: column
## Que vaut $P^{(5)}$ (10min)?
. . .
$$
P^{(5)}=\begin{bmatrix}
- & 1 & 1 & 5 & 1 \\
2 & - & 1 & 5 & 2 \\
2 & 3 & - & 3 & 3 \\
4 & 1 & 1 & - & 1 \\
4 & 1 & 1 & 5 & - \\
\end{bmatrix}
$$
::::
:::
# Exercice: retrouver le chemin entre 1 et 4 (5min)
$$
P=\begin{bmatrix}
- & 1 & 1 & 5 & 1 \\
2 & - & 1 & 5 & 2 \\
2 & 3 & - & 3 & 3 \\
4 & 1 & 1 & - & 4 \\
4 & 1 & 1 & 5 & - \\
\end{bmatrix}
$$
. . .
## Solution
* Le sommet $5=P_{14}$, on a donc, $5\rightarrow 4$, on veut connaître le prédécesseur de 5.
* Le sommet $1=P_{15}$, on a donc, $1\rightarrow 5\rightarrow 4$. The end.
# Exercice complet
## Appliquer l'algorithme de Floyd--Warshall au graphe suivant
![The exorcist.](figs/floyd_exercice.png){width=50%}
* Bien indiquer l'état de $D$ et $P$ à chaque étape!
* Ne pas oublier de faire la matrice d'adjacence évidemment...