Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
C
cours
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
algorithmique
cours
Commits
54c65708
Verified
Commit
54c65708
authored
3 years ago
by
orestis.malaspin
Browse files
Options
Downloads
Patches
Plain Diff
correct some pseudo-code mistakes in 16. split with 17 for next class. todo avl trees
parent
a94b39fe
No related branches found
No related tags found
No related merge requests found
Pipeline
#15880
passed
3 years ago
Stage: test
Changes
2
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
slides/cours_16.md
+4
-114
4 additions, 114 deletions
slides/cours_16.md
slides/cours_17.md
+875
-0
875 additions, 0 deletions
slides/cours_17.md
with
879 additions
and
114 deletions
slides/cours_16.md
+
4
−
114
View file @
54c65708
...
...
@@ -277,10 +277,11 @@ arbre suppression(arbre, clé)
arbre parent(arbre, sous_arbre)
si est_non_vide(arbre)
actuel = arbre
parent = actuel
clé = clé(sous_arbre)
faire
parent = actuel
si (clé != clé(actuel))
parent = actuel
si clé < clé(actuel)
actuel = gauche(actuel)
sinon
...
...
@@ -324,9 +325,9 @@ arbre suppression(arbre, clé)
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(sous_arbre, clé)
max_gauche = position(
gauche(
sous_arbre
)
, clé)
échange(clé(max_gauche), clé(sous_arbre))
suppression(sous_arbre, clé)
#
suppression(
gauche(
sous_arbre
)
, clé)
```
# Exercices (poster sur matrix)
...
...
@@ -1195,114 +1196,3 @@ graph TD;
*
Postez le résultat sur matrix.
# L'algorithme du tri par tas (1/4)
\f
ootnotesize
## 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)
\f
ootnotesize
## 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)
\f
ootnotesize
## 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;
}
```
This diff is collapsed.
Click to expand it.
slides/cours_17.md
0 → 100644
+
875
−
0
View file @
54c65708
---
title
:
"
Arbres
et
tri
par
tas"
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$:
`7`
.
*
`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)
\f
ootnotesize
## 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)
\f
ootnotesize
## 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)
\f
ootnotesize
## 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;
}
```
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment