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
a009867b
Verified
Commit
a009867b
authored
3 years ago
by
orestis.malaspin
Browse files
Options
Downloads
Patches
Plain Diff
split cours 9 and 10
parent
41708b2a
No related branches found
Branches containing commit
No related tags found
No related merge requests found
Pipeline
#14997
passed
3 years ago
Stage: test
Changes
2
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
slides/cours_10.md
+452
-0
452 additions, 0 deletions
slides/cours_10.md
slides/cours_9.md
+0
-435
0 additions, 435 deletions
slides/cours_9.md
with
452 additions
and
435 deletions
slides/cours_10.md
0 → 100644
+
452
−
0
View file @
a009867b
---
title: "Piles et files d'attente"
date: "2021-12-08"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
...
# La liste chaînée et pile (1/N)
## Structure de données
*
Chaque élément de la liste contient:
1.
une valeur,
2.
un pointeur vers le prochain élément.
*
La pile est un pointeur vers le premier élément.

{width=80%}
# La liste chaînée et pile (2/N)
## Une pile-liste-chaînée
```
C
typedef struct _element {
int data;
struct _element *next;
} element;
typedef element* stack;
```
## Fonctionnalités?
. . .
```
C
void stack_create(stack *s); // *s = 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;
```
# La liste chaînée et pile (3/N)
## Empiler? (faire un dessin)
. . .
```
C
```
## Empiler? (le code ensemble)
. . .
```
C
void stack_push(stack *s, int val) {
element *elem = malloc(sizeof(*elem));
elem->data = val;
elem->next = *stack;
stack = elem;
}
```
# La liste chaînée et pile (4/N)
## Jeter un oeil? (faire un dessin)
. . .
```
C
```
## Jeter un oeil? (le code ensemble)
. . .
```
C
void stack_peek(stack s, int *val) {
*val = s->data;
}
```
# La liste chaînée et pile (5/N)
## Dépiler? (faire un dessin)
. . .
```
C
```
## Dépiler? (le code ensemble)
. . .
```
C
void stack_pop(stack *s, int *val) {
stack_peek(*s, val);
element *tmp = *s;
*s = (*s)->next;
free(tmp);
return val;
}
```
# La liste chaînée et pile (6/N)
## Détruire? (faire un dessin)
. . .
```
C
```
## Détruire? (le code ensemble)
. . .
```
C
void stack_destroy(stack *s) {
while (!stack_is_empty(*s)) {
int val = stack_pop(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)
## 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).

## 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):
. . .

{width=40%}
2.
La file n'est pas vide (faire un dessin):
. . .

{width=70%}
# Enfilage
## Live (implémentation)
. . .
```
C
```
# Défilage
## Trois cas différents
1.
La file a plus d'un élément (faire un dessin):
. . .

{width=80%}
2.
La file un seul élément (faire un dessin):
. . .

{width=25%}
3.
La file est vide (problème)
# Défilage
## Live (implémentation)
. . .
```
C
```
# 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);
*
`head`
et
`tail`
seraient les indices du tableau;
*
`capacity`
seraient la capacité maximale;
. . .
## Structure de données
```
C
typedef struct _queue {
int *data;
int head, 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
```
# File basée sur un tableau (git)
*
Créons le squelette et
`Makefile`
ensemble.
. . .
*
Créons quelques issues et assignons les!
This diff is collapsed.
Click to expand it.
slides/cours_9.md
+
0
−
435
View file @
a009867b
...
...
@@ -507,438 +507,3 @@ bool evaluate(char *postfix, double *val) { // init stack
}
```
# La liste chaînée et pile (1/N)
## Structure de données
*
Chaque élément de la liste contient:
1.
une valeur,
2.
un pointeur vers le prochain élément.
*
La pile est un pointeur vers le premier élément.

{width=80%}
# La liste chaînée et pile (2/N)
## Une pile-liste-chaînée
```
C
typedef struct _element {
int data;
struct _element *next;
} element;
typedef element* stack;
```
## Fonctionnalités?
. . .
```
C
void stack_create(stack *s); // *s = 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;
```
# La liste chaînée et pile (3/N)
## Empiler? (faire un dessin)
. . .
```
C
```
## Empiler? (le code ensemble)
. . .
```
C
void stack_push(stack *s, int val) {
element *elem = malloc(sizeof(*elem));
elem->data = val;
elem->next = *stack;
stack = elem;
}
```
# La liste chaînée et pile (4/N)
## Jeter un oeil? (faire un dessin)
. . .
```
C
```
## Jeter un oeil? (le code ensemble)
. . .
```
C
void stack_peek(stack s, int *val) {
*val = s->data;
}
```
# La liste chaînée et pile (5/N)
## Dépiler? (faire un dessin)
. . .
```
C
```
## Dépiler? (le code ensemble)
. . .
```
C
void stack_pop(stack *s, int *val) {
stack_peek(*s, val);
element *tmp = *s;
*s = (*s)->next;
free(tmp);
return val;
}
```
# La liste chaînée et pile (6/N)
## Détruire? (faire un dessin)
. . .
```
C
```
## Détruire? (le code ensemble)
. . .
```
C
void stack_destroy(stack *s) {
while (!stack_is_empty(*s)) {
int val = stack_pop(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)
## 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).

## 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):
. . .

{width=40%}
2.
La file n'est pas vide (faire un dessin):
. . .

{width=70%}
# Enfilage
## Live (implémentation)
. . .
```
C
```
# Défilage
## Trois cas différents
1.
La file a plus d'un élément (faire un dessin):
. . .

{width=80%}
2.
La file un seul élément (faire un dessin):
. . .

{width=25%}
3.
La file est vide (problème)
# Défilage
## Live (implémentation)
. . .
```
C
```
# 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);
*
`head`
et
`tail`
seraient les indices du tableau;
*
`capacity`
seraient la capacité maximale;
. . .
## Structure de données
```
C
typedef struct _queue {
int *data;
int head, 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
```
# File basée sur un tableau (git)
*
Créons le squelette et
`Makefile`
ensemble.
. . .
*
Créons quelques issues et assignons les!
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