Skip to content
Snippets Groups Projects
Verified Commit 5420735e authored by orestis.malaspin's avatar orestis.malaspin
Browse files

moved part of 10 in 11

parent a3e230bd
No related branches found
No related tags found
No related merge requests found
Pipeline #15022 passed
Stage: test
Hide whitespace changes
Inline Side-by-side
slides/cours_10.md
+ 0
− 235
View file @ 5420735e
......@@ -319,238 +319,3 @@ int queue_dequeue(queue *fa) {
## 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épiler?
. . .
* Détruire?
. . .
* Est vide?
# Implémentation alternative
## Comment implémenter la file auterment?
. . .
* Données stockées dans un tableau;
* Tableau de taille connue à la compilation ou pas (reallouable);
* `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
```
* Empiler?
. . .
```C
```
* Dépiler?
. . .
```C
```
# Complexité
## Quelle sont les complexité de:
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Empiler?
. . .
```C
```
* Dépiler?
. . .
```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;
```
# File basée sur un tableau (git)
* Créons le squelette et `Makefile` ensemble.
* On doit choisir: cas simple ou cas compliqué?
. . .
* Créons quelques issues et assignons les!
# 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
## Quelle structure de données?
Une liste chaînée bien sûr!
```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
# L'extraction
# La recherche
# Exercice: recherche sans position
slides/cours_11.md 0 → 100644
+ 407
− 0
View file @ 5420735e
---
title: "Files d'attente et listes triées"
date: "2021-12-15"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
...
# 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)
## Implémentation possible
* La structure file, contient un pointeur vers la tête et un vers la queue.
* Entre les deux, les éléments sont stockés dans une liste chaînée (comme une
pile).
![Illustration d'une file
d'attente.](figs/fig_queue_representation.png)
## Structure de données en C?
. . .
```C
txpedef 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 (gitlab)
## 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.head->data
int queue_head(queue fa); // return fa.tail->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) {
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épiler?
. . .
* Détruire?
. . .
* Est vide?
# Implémentation alternative
## Comment implémenter la file auterment?
. . .
* Données stockées dans un tableau;
* Tableau de taille connue à la compilation ou pas (reallouable);
* `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
```
* Empiler?
. . .
```C
```
* Dépiler?
. . .
```C
```
# Complexité
## Quelle sont les complexité de:
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Empiler?
. . .
```C
```
* Dépiler?
. . .
```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;
```
# File basée sur un tableau (git)
* Créons le squelette et `Makefile` ensemble.
* On doit choisir: cas simple ou cas compliqué?
. . .
* Créons quelques issues et assignons les!
# 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
## Quelle structure de données?
Une liste chaînée bien sûr!
```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
# L'extraction
# La recherche
# Exercice: recherche sans position
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment