Skip to content
Snippets Groups Projects
Commit e6516274 authored by Pierre Kunzli's avatar Pierre Kunzli
Browse files

Merge branch 'master' into pk

parents 2c3e0a0f 295b1052
Branches
No related tags found
3 merge requests!6Pk,!5Pk,!4correction recherche parent et ajout sauts slides
This commit is part of merge request !5. Comments created here will be created in the context of that merge request.
Showing
with 2393 additions and 136 deletions
...@@ -3,3 +3,4 @@ ...@@ -3,3 +3,4 @@
*.markdown *.markdown
*.html *.html
index.md index.md
.puppeteer.json
{
"executablePath": "/usr/bin/chromium-browser",
"args": ["--no-sandbox"]
}
...@@ -278,6 +278,7 @@ arbre suppression(arbre, clé) ...@@ -278,6 +278,7 @@ arbre suppression(arbre, clé)
arbre parent(arbre, sous_arbre) arbre parent(arbre, sous_arbre)
si est_non_vide(arbre) si est_non_vide(arbre)
actuel = arbre actuel = arbre
parent = actuel
clé = clé(sous_arbre) clé = clé(sous_arbre)
faire faire
si (clé != clé(actuel)) si (clé != clé(actuel))
...@@ -319,15 +320,17 @@ arbre suppression(arbre, clé) ...@@ -319,15 +320,17 @@ arbre suppression(arbre, clé)
# Le pseudo-code de la suppression # Le pseudo-code de la suppression
\footnotesize
## Pour au moins deux enfants (ensemble) ## Pour au moins deux enfants (ensemble)
``` ```
arbre suppression(arbre, clé) arbre suppression(arbre, clé)
sous_arbre = position(arbre, clé) # on revérifie pas que c'est bien la 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)) si est_non_vide(gauche(sous_arbre)) et est_non_vide(droite(sous_arbre))
max_gauche = position(sous_arbre, clé) max_gauche = position(gauche(sous_arbre), clé)
échange(clé(max_gauche), clé(sous_arbre)) échange(clé(max_gauche), clé(sous_arbre))
suppression(sous_arbre, clé) # suppression(gauche(sous_arbre), clé)
``` ```
# Exercices (poster sur matrix) # Exercices (poster sur matrix)
...@@ -1196,112 +1199,3 @@ graph TD; ...@@ -1196,112 +1199,3 @@ graph TD;
* Postez le résultat sur matrix. * Postez le résultat sur matrix.
# L'algorithme du tri par tas (1/4)
## Deux étapes
1. Entassement (tamisage): 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 (5 min, matrix)
. . .
```
tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i = size(tab)-1 à 2
promotion(tab, i)
échanger(tab[0], tab[i-1])
entassement(tab)
pour i = size(tab) / 2 - 1 jusqu'à 0
promotion(tab, i)
promotion(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
promotion(tab, ind_max)
```
# L'algorithme du tri par tas (2/4)
* Fonctions utilitaires
```
int ind_max(tab, i, g, d)
ind_max = i
si tab[ind_max] < tab[l]
ind_max = l
si tab[ind_mx] < tab[r]
ind_max = r
retourne ind_max
int gauche(i)
retourne 2 * i + 1
int droite(i)
retourne 2 * i + 2
```
# L'algorithme du tri par tas (3/4)
\footnote size
## 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 (3/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;
}
```
+ 1129
0
View file @ e6516274
---
title: "Tri par tas et arbres AVL"
date: "2022-03-09"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Questions sur les notions du dernier cours
* Comment représenter un tableau sous forme d'arbre binaire?
. . .
* Qu'est-ce qu'un tas?
# Exemple de tri par tas (1/N)
```
| 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 = 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
```
::::
:::
. . .
```
* *
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
# Exemple de tri par tas (2/N)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
::: 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
```
::::
:::: 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)`)
```{.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/N)
```
| 1 | 16 | 5 | 12 | 7 | 2 | 8 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* 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
```
::::
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-2 = 3$: `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/N)
```
| 1 | 16 | 8 | 12 | 7 | 2 | 5 | 10 | 6 | 4 |
```
::: columns
:::: column
**But:** Transformer l'arbre en tas.
* Indice $N/2-3 = 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-4 = 1$: `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/N)
```
| 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/N)
```
| 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/N)
```
| 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/N)
```
| 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/N)
```
| 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/N)
```
| 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=400 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=400 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/N)
```
| 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=400 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/N)
```
| 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/N)
```
| 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/4)
\footnotesize
## Deux étapes
1. Entassement (tamisage): 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 (5 min, matrix)
. . .
```
tri_par_tas(tab)
entassement(tab)
échanger(tab[0], tab[size(tab)-1])
pour i = size(tab)-1 à 2
promotion(tab, 0)
échanger(tab[0], tab[i-1])
entassement(tab)
pour i = size(tab) / 2 - 1 jusqu'à 0
promotion(tab, i)
promotion(tab, i)
ind_max = ind_max(tab, i, gauche(i), droite(i))
si i != ind_max
échanger(tab[i], tab[ind_max])
promotion(tab, ind_max)
```
# L'algorithme du tri par tas (2/4)
* Fonctions utilitaires
```
int ind_max(tab, i, g, d)
ind_max = i
si tab[ind_max] < tab[l]
ind_max = l
si tab[ind_mx] < tab[r]
ind_max = r
retourne ind_max
int gauche(i)
retourne 2 * i + 1
int droite(i)
retourne 2 * i + 2
```
# L'algorithme du tri par tas (3/4)
\footnotesize
## Implémenter en C l'algorithme du tri par tas (matrix, 20min)
. . .
```C
void heapsort(int size, int tab[size]) {
heapify(size, tab);
swap(tab, tab + size - 1);
for (int s = size - 1; s > 1; s--) {
sift_up(s, tab, 0);
swap(tab, tab + s - 1);
}
}
void heapify(int size, int tab[size]) {
for (int i = size / 2 - 1; i >= 0; i--) {
sift_up(size, tab, i);
}
}
void sift_up(int size, int tab[size], int i) {
int ind_max = ind_max3(size, tab, i, left(i), right(i));
if (i != ind_max) {
swap(tab + i, tab + ind_max);
sift_up(size, tab, ind_max);
}
}
```
# L'algorithme du tri par tas (4/4)
\footnotesize
## Fonctions utilitaires
. . .
```C
int ind_max3(int size, int tab[size], int i, int l, int r) {
int ind_max = i;
if (l < size && tab[ind_max] < tab[l]) {
ind_max = l;
}
if (r < size && tab[ind_max] < tab[r]) {
ind_max = r;
}
return ind_max;
}
void swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
int left(int i) {
return 2 * i + 1;
}
int right(int i) {
return 2 * i + 2;
}
```
# Complexités
::: columns
:::: column
## Complexité de la recherche
1. En moyenne?
2. Dans le pire des cas?
. . .
1. $O(\log_2(N))$
2. $O(N)$
::::
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((10))-->id1((9));
id0-->id8(( ));
id1-->id2((7));
id1-->id9(( ));
id2-->id3((6));
id2-->id10(( ));
id3-->id4((5));
id3-->id11(( ));
style id8 fill:#fff,stroke:#fff
style id9 fill:#fff,stroke:#fff
style id10 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::
# Un meilleur arbre
* Quelle propriété doit satisfaire un arbre pour être $O(\log_2(N))$?
. . .
* Si on a environ le même nombre de noeuds dans les sous-arbres.
## Définition
Un arbre binaire est parfaitement équilibré si, pour chaque
nœud, la différence entre les nombres de nœuds des sous-
arbres gauche et droit vaut au plus 1.
* Si l'arbre est **parfaitement équilibré**, alors tout ira bien.
* Quelle est la hauteur (profondeur) d'un arbre parfaitement équilibré?
. . .
* $O(\log_2(N))$.
# Équilibre parfait ou pas?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((W))-->id1((B));
id0-->id8((Y));
id1-->id2((A));
id1-->id9(( ));
id8-->id10((X));
id8-->id11(( ));
style id9 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
```
É
Q
U
I
L
I
B
R
É
```
::::
:::
# Équilibre parfait ou pas?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((16))-->id1((10));
id0-->id2((19));
id1-->id3((8));
id1-->id4((12));
id4-->id5((11));
id4-->id6(( ));
id2-->id7((17));
id2-->id8(( ));
id7-->id9(( ));
id7-->id10((18));
style id6 fill:#fff,stroke:#fff
style id8 fill:#fff,stroke:#fff
style id9 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
```
P
A
S
É
Q
U
I
L
I
B
R
É
```
::::
:::
# Arbres AVL
* 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 neouds:
* 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 noeuds et hauteur:
$$
\log_2(1+N)\leq 1+H\leq 1.44\cdot\log_2(2+N),\quad N=10^5,\ 17\leq H \leq 25.
$$
* Permet l'équilibrage en temps constant: insertion/suppression $O(\log_2(N))$.
# Notation
* `hg`: hauteur du sous-arbre gauche.
* `hd`: hauteur du sous-arbre droit.
* `facteur d'équilibre = fe = hd - hg`
* Que vaut `fe` si l'arbre est AVL?
. . .
* `fe = {-1, 0, 1}`
# AVL ou pas?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((10));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
```
::::
:::: column
. . .
```
A
V
L
```
::::
:::
# AVL ou pas?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((17));
id2-->id4((97));
id4-->id5((37));
id4-->id6(( ));
style id6 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
```
P
A
S
A
V
L
```
::::
:::
+ 1022
0
View file @ e6516274
---
title: "Tri par tas et arbres AVL"
date: "2022-03-16"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Questions sur les notions du dernier cours
* Qu'est-ce qu'un arbre AVL?
. . .
* Un arbre binaire qui a la propriété suivante:
* La différence de hauteur de chaque noeud est d'au plus 1.
* Tous les noeuds ont `fe = hd - hg = {-1, 0, 1}`.
# AVL ou pas?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((21))-->id1((9));
id0-->id2((40));
id1-->id3((5));
id1-->id4((10));
id3-->id5((3));
id3-->id6((7))
id6-->id7((6))
id6-->id8(( ))
id2-->id9((33))
id2-->id10((61))
id9-->id11((22))
id9-->id12((39))
id10-->id13(( ))
id10-->id14((81))
style id8 fill:#fff,stroke:#fff
style id13 fill:#fff,stroke:#fff
```
. . .
* Ajouter un noeud pour qu'il le soit plus.
# Insertion dans un arbre AVL (1/N)
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
```
::::
:::: column
. . .
* `hd = hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id1-->id4(( ));
id1-->id5((4));
style id4 fill:#fff,stroke:#fff
```
* `fe = -1`
::::
:::
# Insertion dans un arbre AVL (2/N)
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((18));
id2-->id4(( ));
style id4 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
* `hd < hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id2-->id3((18));
id2-->id4(( ));
id1-->id5(( ));
id1-->id6((4));
style id4 fill:#fff,stroke:#fff
style id5 fill:#fff,stroke:#fff
```
* `fe = 0`
::::
:::
# Insertion dans un arbre AVL (3/N)
1. On part d'un arbre AVL.
2. On insère un nouvel élément.
::: columns
:::: column
* `hd ? hg`.
* Insertion de `4`?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id1-->id3(( ));
id1-->id4((6));
id2-->id5(( ));
id2-->id6(( ));
style id3 fill:#fff,stroke:#fff
style id5 fill:#fff,stroke:#fff
style id6 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
* `hd > hg`
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((12))-->id1((1));
id0-->id2((19));
id1-->id3(( ));
id1-->id4((6));
id4-->id5((4));
id4-->id6(( ));
id2-->id7(( ));
id2-->id8(( ));
style id3 fill:#fff,stroke:#fff
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
style id8 fill:#fff,stroke:#fff
```
::::
:::
**Déséquilibre!** Que vaut `fe`?
. . .
* `fe = 2`
# Les cas de déséquilibre
::: columns
:::: column
## Cas 1a
* `u`, `v`, `w` même hauteur.
* déséquilibre en `B` après insertion dans `u`
![Après insertion](figs/cas1a_gauche.png)
::::
:::: column
## Cas 1a
* Comment rééquilibrer?
. . .
* ramène `u`, `v` `w` à la même hauteur.
* `v` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas1a_droite.png)
::::
:::
# Les cas de déséquilibre
::: columns
:::: column
## Cas 1b (symétrique 1a)
![Après insertion](figs/cas1b_gauche.png)
::::
:::: column
## Cas 1b (symétrique 1a)
* Comment rééquilibrer?
. . .
![Après équilibrage](figs/cas1b_droite.png)
::::
:::
# Les cas de déséquilibre
::: columns
:::: column
## Cas 2a
* `v1`, `v2`, `u`, `w` même hauteur.
* déséquilibre en `C` après insertion dans `v2`
![Après insertion](figs/cas2a_gauche.png)
::::
:::: column
## Cas 2a
* Comment rééquilibrer?
. . .
* ramène `u`, `v1`, `v2`, `w` à la même hauteur.
* `v2` à droite de `B` (gauche de `C`)
* `B` à droite de `A` (gauche de `C`)
* `v1` à droite de `A` (gauche de `B`)
![Après équilibrage](figs/cas2a_droite.png)
::::
:::
# Les cas de déséquilibre
::: columns
:::: column
## Cas 2b (symétrique 2a)
![Après insertion](figs/cas2b_gauche.png)
::::
:::: column
## Cas 2b (symétrique 2a)
* Comment rééquilibrer?
. . .
![Après équilibrage](figs/cas2b_droite.png)
::::
:::
# Le facteur d'équilibre (balance factor)
## Définition
```
fe(arbre) = hauteur(droite(arbre)) - hauteur(gauche(arbre))
```
## Valeurs possibles?
. . .
```
fe = {-1, 0, 1} // arbre AVL
fe = {-2, 2} // arbre déséquilibré
```
![Illustration du `fe`](figs/facteur_equilibre.png){width=40%}
# Algorithme d'insertion
* Insérer le noeud comme d'habitude.
* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
noeud déséquilibré).
* Rééquilibrer le noeud si nécessaire.
## Cas possibles
::: columns
:::: column
## Sous-arbre gauche (avant)
```
fe(P) = 1
fe(P) = 0
fe(P) = -1
```
::::
:::: column
## Sous-arbre gauche (après)
. . .
```
=> fe(P) = 0
=> fe(P) = -1
=> fe(P) = -2 // Rééquilibrer P
```
::::
:::
# Algorithme d'insertion
* Insérer le noeud comme d'habitude.
* Mettre à jour les facteurs d'équilibre jusqu'à la racine (ou au premier
noeud déséquilibré).
* Rééquilibrer le noeud si nécessaire.
## Cas possibles
::: columns
:::: column
## Sous-arbre droit (avant)
```
fe(P) = 1
fe(P) = 0
fe(P) = -1
```
::::
:::: column
## Sous-arbre droit (après)
. . .
```
=> fe(P) = 0
=> fe(P) = +1
=> fe(P) = +2 // Rééquilibrer P
```
::::
:::
# Rééquilibrage
## Lien avec les cas vus plus tôt
```
fe(P) = -2 && fe(gauche(P)) = -1 => cas 1a
fe(P) = -2 && fe(gauche(P)) = +1 => cas 2a
fe(P) = +2 && fe(gauche(P)) = -1 => cas 1b
fe(P) = +2 && fe(gauche(P)) = +1 => cas 2b
```
## Dessiner les différents cas, sur le dessin ci-dessous
![On verra un peu après les rotations.](figs/rotation_gauche_droite.png)
# La rotation
## La rotation gauche (5min, matrix)
![L'arbre de droite devient celui de gauche. Comment?](figs/rotation_gauche_droite.png)
. . .
```
arbre rotation_gauche(arbre P)
si est_non_vide(P)
Q = droite(P)
droite(P) = gauche(Q)
gauche(Q) = droite(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) = droite(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)`
. . .
```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->lefe;
}
return subtree;
}
```
. . .
* Et la rotation à droite (5min)?
```C
tree_t rotation_right(tree_t tree) {
tree_t subtree = NULL;
if (NULL != tree) {
subtree = tree->left;
tree->left = subtree->right;
subtree->right = tree;
}
return subtree;
}
```
# Exemple de rotation (1/2)
## Insertion de 9?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((5))-->id1((1));
id0-->id2((6));
id2-->id3(( ));
id2-->id4((8));
style id3 fill:#fff,stroke:#fff
```
# Exemple de rotation (2/2)
::: columns
:::: column
## Quelle rotation et sur quel noeud (5 ou 6)?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((5))-->id1((1));
id0-->id2((6));
id2-->id3(( ));
id2-->id4((8));
id4-->id5(( ));
id4-->id6((9));
style id3 fill:#fff,stroke:#fff
style id5 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Sur le plus jeune évidemment!
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((5))-->id1((1));
id0-->id2((8));
id2-->id3((6));
id2-->id4((9));
```
::::
:::
* Cas `1a/b` *check*!
# La rotation gauche-droite
## Là c'est plus difficile (cas 2a/b)
![La double rotation de l'enfer.](figs/double_rotation_gauche_droite.png)
# Exercices
## Faire l'implémentation de la double rotation (pas corrigé 15min)
. . .
::: columns
:::: column
## Insérer 50, ex 10min (matrix)
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((89))-->id1((71));
id0-->id2((90));
id1-->id3((44));
id3-->id4((37));
id3-->id5((61));
id1-->id6((81))
id2-->id7(( ))
id2-->id8((100))
style id7 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Où se fait la rotation?
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((89))-->id1((71));
id0-->id2((90));
id1-->id3((44));
id3-->id4((37));
id3-->id5((61));
id1-->id6((81))
id2-->id7(( ))
id2-->id8((100))
id5-->id9((50))
id5-->id10(( ))
style id7 fill:#fff,stroke:#fff
style id10 fill:#fff,stroke:#fff
```
::::
:::
# Exercices
::: columns
:::: column
## Rotation gauche en 44
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((89))-->id1((71));
id0-->id2((90));
id1-->id3((61));
id1-->id10((81));
id3-->id4((44));
id3-->id5(( ));
id4-->id6((37))
id4-->id7((50))
id2-->id8(( ))
id2-->id9((100))
style id5 fill:#fff,stroke:#fff
style id8 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Rotation à droite en 71
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((89))-->id1((61));
id0-->id2((90));
id1-->id3((44));
id1-->id10((71));
id3-->id4((37));
id3-->id5((50));
id2-->id8(( ));
id2-->id9((100));
id10-->id11(( ))
id10-->id12((81))
style id8 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::
# Exercice de la mort
Soit l’arbre AVL suivant:
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((60))-->id1((40));
id0-->id2((120));
id1-->id3((20));
id1-->id4((50));
id3-->id5((10));
id3-->id6((30));
id2-->id7((100));
id2-->id8((140));
id7-->id9((80))
id7-->id10((110))
id9-->id11((70))
id9-->id12((90))
id8-->id13((130))
id8-->id14((160))
id14-->id15((150))
id14-->id16((170))
```
::::
:::: column
1. Montrer les positions des insertions de feuille qui conduiront à un arbre
désequilibré.
2. Donner les facteurs d’equilibre.
3. Dessiner et expliquer les modifications de l’arbre lors de l’insertion de la
valeur `65`. On mentionnera les modifications des facteurs
d’équilibre.
::::
:::
# Encore un petit exercice
* Insérer les noeuds suivants dans un arbre AVL
```
25 | 60 | 35 | 10 | 5 | 20 | 65 | 45 | 70 | 40 | 50 | 55 | 30 | 15
```
## Un à un et le/la premier/ère qui poste la bonne réponse sur matrix à un point
# Suppression dans un arbre AVL
::: columns
:::: column
## Algorithme par problème: supprimer 10
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((8))-->id1((4));
id0-->id2((10));
id1-->id3((2));
id1-->id4((6));
id3-->id5((1));
id3-->id6(( ))
id4-->id7(( ))
id4-->id8((7))
id2-->id9((9))
id2-->id10((14))
id10-->id11((12))
id10-->id12((16))
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Algorithme par problème: supprimer 10
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((8))-->id1((4));
id0-->id2((12));
id1-->id3((2));
id1-->id4((6));
id3-->id5((1));
id3-->id6(( ))
id4-->id7(( ))
id4-->id8((7))
id2-->id9((9))
id2-->id10((14))
id10-->id11(( ))
id10-->id12((16))
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::
# Suppression dans un arbre AVL
::: columns
:::: column
## Algorithme par problème: supprimer 8
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((8))-->id1((4));
id0-->id2((12));
id1-->id3((2));
id1-->id4((6));
id3-->id5((1));
id3-->id6(( ))
id4-->id7(( ))
id4-->id8((7))
id2-->id9((9))
id2-->id10((14))
id10-->id11(( ))
id10-->id12((16))
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Algorithme par problème: rotation de 12
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((9))-->id1((4));
id0-->id2((12));
id1-->id3((2));
id1-->id4((6));
id3-->id5((1));
id3-->id6(( ))
id4-->id7(( ))
id4-->id8((7))
id2-->id9(( ))
id2-->id10((14))
id10-->id11(( ))
id10-->id12((16))
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
style id9 fill:#fff,stroke:#fff
style id11 fill:#fff,stroke:#fff
```
::::
:::
# Suppression dans un arbre AVL
::: columns
:::: column
## Algorithme par problème: rotation de 12
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((9))-->id1((4));
id0-->id2((14));
id1-->id3((2));
id1-->id4((6));
id3-->id5((1));
id3-->id6(( ))
id4-->id7(( ))
id4-->id8((7))
id2-->id9((12))
id2-->id10((16))
style id6 fill:#fff,stroke:#fff
style id7 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
1. On supprime comme d'habitude.
2. On rééquilibre si besoin à l'endroit de la suppression.
* Facile non?
. . .
* Plus dur....
::::
:::
# Suppression dans un arbre AVL 2.0
::: columns
:::: column
## Algorithme par problème: suppression de 30
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((50))-->id1((30));
id0-->id2((100));
id1-->id3((10));
id1-->id4((40));
id3-->id5(( ));
id3-->id6((20))
id2-->id7((80))
id2-->id8((200))
id7-->id9((70))
id7-->id10((90))
id9-->id11((60))
id9-->id12(( ))
id8-->id13(( ))
id8-->id14((300))
style id5 fill:#fff,stroke:#fff
style id12 fill:#fff,stroke:#fff
style id13 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Algorithme par problème: rotation GD autour de 40
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((50))-->id1((40));
id0-->id2((100));
id1-->id3((10));
id1-->id4(( ));
id3-->id5(( ));
id3-->id6((20))
id2-->id7((80))
id2-->id8((200))
id7-->id9((70))
id7-->id10((90))
id9-->id11((60))
id9-->id12(( ))
id8-->id13(( ))
id8-->id14((300))
style id4 fill:#fff,stroke:#fff
style id5 fill:#fff,stroke:#fff
style id12 fill:#fff,stroke:#fff
style id13 fill:#fff,stroke:#fff
```
::::
:::
# Suppression dans un arbre AVL 2.0
::: columns
:::: column
## Argl! 50 est déséquilibré!
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((50))-->id1((20));
id0-->id2((100));
id1-->id3((10));
id1-->id4((40));
id2-->id7((80))
id2-->id8((200))
id7-->id9((70))
id7-->id10((90))
id9-->id11((60))
id9-->id12(( ))
id8-->id13(( ))
id8-->id14((300))
style id12 fill:#fff,stroke:#fff
style id13 fill:#fff,stroke:#fff
```
::::
:::: column
. . .
## Algorithme par problème: rotation DG autour de 50
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
id0((80))-->id1((50));
id0-->id2((100));
id1-->id3((20));
id1-->id4((70));
id3-->id5((10));
id3-->id6((40));
id4-->id9((60))
id4-->id10(( ))
id2-->id7((90))
id2-->id8((200))
id8-->id13(( ))
id8-->id14((300))
style id10 fill:#fff,stroke:#fff
style id13 fill:#fff,stroke:#fff
```
::::
:::
# Résumé de la suppression
1. On supprime comme pour un arbre binaire de recherche.
2. Si un noeud est déséquilibré, on le rééquilibre.
* Cette opération pour déséquilibrer un autre noeud.
3. On continue à rééquilibrer tant qu'il y a des noeuds à équilibrer.
slides/figs/cas1a_droite.png

70.3 KiB

slides/figs/cas1a_gauche.png

71.7 KiB

slides/figs/cas1b_droite.png

66.6 KiB

slides/figs/cas1b_gauche.png

78.3 KiB

slides/figs/cas2a_droite.png

82.1 KiB

slides/figs/cas2a_gauche.png

99.7 KiB

slides/figs/cas2b_droite.png

93.3 KiB

slides/figs/cas2b_gauche.png

100 KiB

slides/figs/double_rotation_gauche_droite.png

65.8 KiB

slides/figs/facteur_equilibre.png

35.9 KiB

slides/figs/rotation_gauche_droite.png

56.9 KiB

#!/bin/bash #!/bin/bash
set -e
function get_info() {
local field=$(echo "$fullName" | sed "$2q;d" $1);
IFS=$3;
local field=($field);
if [ "${field}" != $5 ]; then
return 1
fi
local field=${field[1]};
IFS=$4;
local field=($field);
local field=${field[1]};
echo "$field"
}
function fail() {
printf '%s\n' "$1" >&2 ## Send message to stderr.
exit "${2-1}" ## Return a code specified by $2, or 1 by default.
}
OIFS=$IFS OIFS=$IFS
NUM_LINE=2 NUM_LINE=2
PREFIX="" PREFIX=""
...@@ -8,36 +29,27 @@ PREFIX="" ...@@ -8,36 +29,27 @@ PREFIX=""
classes=() classes=()
for i in *.md; do for i in *.md; do
[ -f "$i" ] || break [ -f "$i" ] || break
comp=$(echo "$fullName" | sed "${NUM_LINE}q;d" $i) date="$(get_info $i 3 ":" '"' "date")"
date=$(echo "$fullName" | sed "3q;d" $i) if [ "$date" == 1 ]; then
IFS=':' fail "Error date field not found"
comp=($comp); fi
comp=${comp[1]} comp="$(get_info $i 2 ":" '"' "title")"
date=($date); if [ "$comp" == 1 ]; then
date=${date[1]} fail "Error title field not found"
# echo $comp fi
IFS='"'
comp=($comp)
comp=${comp[1]}
date=($date);
date=${date[1]}
# echo $comp | awk '{ print substr( $0, 1, length($0)-1 ) }'
# echo $comp
# date=sed "${NUM_LINE}q;d" $i
i="${i%.*}" i="${i%.*}"
class="[${date} ${comp}](${PREFIX}${i}.pdf)" class="[${date} ${comp}](${PREFIX}${i}.pdf)"
classes+=($class) classes+=("$class")
# echo "[${date} ${comp}](${PREFIX}${i}.pdf)" >> index.md
done done
IFS=$'\n' IFS=$'\n'
classes=($(sort <<<"${classes[*]}")) classes=($(sort <<<"${classes[*]}"))
date=$(date '+%Y-%m-%d') date=$(date '+%Y-%m-%d')
echo "---" >> index.md echo "---" >> index.md
echo "title: Slides du cours d'Algorithmique" >> index.md echo "title: \"Slides du cours d'algorithmique\"" >> index.md
echo "date: ${date}" >> index.md echo "date: \"${date}\"" >> index.md
echo "---" >> index.md echo "---" >> index.md
echo "" >> index.md echo "" >> index.md
echo "# Tous les slides du cours d'Algorithmique" >> index.md echo "# Tous les slides du cours d'algorithmique" >> index.md
echo "" >> index.md echo "" >> index.md
for i in ${classes[*]}; do for i in ${classes[*]}; do
echo "* $i" >> index.md echo "* $i" >> index.md
......
bin_tree.o
avl.o
main
main.o
CC:=gcc
# SAN:=-fsanitize=address
CFLAGS:=-Wall -Wextra -pedantic -g $(SAN)
LDFLAGS:=-lm $(SAN)
SOURCES := $(wildcard *.c)
OBJECTS := $(patsubst %.c, %.o, $(SOURCES))
all: main $(OBJECTS)
main: main.c bin_tree.o avl.o
$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
@echo $@ >> .gitignore
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
@echo $@ >> .gitignore
bin_tree.o: bin_tree.h
avl.o: avl.h
.PHONY: clean all
clean:
rm -f *.o main .gitignore
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <stdbool.h>
#include "avl.h"
void avl_print(arbre tree,int N) {
if (N <= 0) {
N = 1;
}
if (NULL != tree) {
avl_print(tree->child[1],N+2);
for (int i=0;i<N;i++) {
printf(" ");
}
printf("%d\n",tree->key);
avl_print(tree->child[0],N+2);
}
}
node* avl_desequilibre(arbre tree,clef key) {
node* crt = tree;
node* parent = NULL;
int h_prec[2] = {0,0};
while (NULL != crt && crt->key != key) {
if (abs(crt->h[1]-crt->h[0]) == 2) {
parent = crt;
h_prec[0] = parent->h[0];
h_prec[1] = parent->h[1];
parent->h[key > parent->key] -= 1;
}
crt = crt->child[key > crt->key];
}
if (NULL != parent) {
parent->h[0] = h_prec[0];
parent->h[1] = h_prec[1];
}
return parent;
}
int avl_height(arbre tree) {
if (NULL == tree) {
return 0;
} else {
return 1+fmax(avl_height(tree->child[0]),avl_height(tree->child[1]))+0.01;
}
}
void avl_heights(arbre tree) {
for (int i=0;i<2;i++) {
if (NULL != tree->child[i]) {
avl_heights(tree->child[i]);
tree->h[i] = 1+fmax(tree->child[i]->h[0],tree->child[i]->h[1])+0.01;
} else {
tree->h[i] = 0;
}
}
}
void avl_height_node(node* nd) {
for (int i=0;i<2;i++) {
if (NULL != nd->child[i]) {
nd->h[i] = 1+fmax(nd->child[i]->h[0],nd->child[i]->h[1])+0.01;
} else {
nd->h[i] = 0;
}
}
}
static node* avl_rot(node* P,bool right) {
node* Q = NULL;
if (NULL != P) {
Q = P->child[right];
P->child[right] = Q->child[!right];
Q->child[!right] = P;
avl_height_node(P);
avl_height_node(Q);
}
return Q;
}
node* avl_rot_g(node* nd) {
return avl_rot(nd,false);
}
node* avl_rot_d(node* nd) {
return avl_rot(nd,true);
}
static node* avl_rot2(node* nd,bool dg) {
nd->child[dg] = avl_rot(nd->child[dg],dg);
return avl_rot(nd,!dg);
}
node* avl_rot_gd(node* nd) {
return avl_rot2(nd,false);
}
node* avl_rot_dg(node* nd) {
return avl_rot2(nd,true);
}
static void avl_rotation(node* nd,bool right) {
node* new_nd = calloc(1,sizeof(node));
new_nd->key = nd->key;
new_nd->child[right] = nd->child[right];
new_nd->child[!right] = nd->child[!right]->child[right];
node* tmp = nd->child[!right];
nd->key = nd->child[!right]->key;
nd->child[right] = new_nd;
nd->child[!right] = nd->child[!right]->child[!right];
avl_height_node(new_nd);
avl_height_node(nd);
free(tmp);
}
void avl_rotation_g(node* nd) {
avl_rotation(nd,false);
}
void avl_rotation_d(node* nd) {
avl_rotation(nd,true);
}
static void avl_rotation2(node* nd,bool dg) {
avl_rotation(nd->child[dg],dg);
avl_rotation(nd,!dg);
}
void avl_rotation_gd(node* nd) {
avl_rotation2(nd,false);
}
void avl_rotation_dg(node* nd) {
avl_rotation2(nd,true);
}
void avl_reequilibre(node* nd) {
switch(nd->h[1]-nd->h[0]) {
case +2:
switch(nd->child[1]->h[1] - nd->child[1]->h[0]) {
case +1: avl_rotation_g(nd); break;
case -1: avl_rotation_dg(nd);
}
break;
case -2:
switch(nd->child[0]->h[1] - nd->child[0]->h[0]) {
case -1: avl_rotation_d(nd); break;
case +1: avl_rotation_gd(nd);
}
}
}
void avl_insert(clef key,arbre* tree,arbre* deseq) {
if (NULL == *tree) {
*tree = calloc(1,sizeof(node));
(*tree)->key = key;
*deseq = NULL;
} else {
avl_insert(key,&((*tree)->child[key > (*tree)->key]),deseq);
if (NULL == *deseq) {
(*tree)->h[key > (*tree)->key]
= 1+fmax((*tree)->child[key > (*tree)->key]->h[0],
(*tree)->child[key > (*tree)->key]->h[1]);
}
if (abs((*tree)->h[1]-(*tree)->h[0]) == 2 && NULL == *deseq) {
*deseq = *tree;
}
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment