A LG O R I T H M I Q U E :

STRUCTURES DE DONNÉES

2 0 2 2 - 2 0 2 3 – 3A I N F O R M AT I Q U E – B . H A S S A N
NOTIONS ABORDÉES

• Modularité
– Modèle d’analyse MVC
– Programmation modulaire en C
• Structures chainees
• Structures dynamiques
• TDA
– Listes chaînées
– Piles
– Files

2
MODULARITÉ
3
MODULARITÉ
• La principale raison de découper son code :
– La réutilisation

• Réutiliser un traitement de données mais l’afficher autrement

– MVC :Modèle Vue Controleur

• Réutiliser une façon de traiter des données :librairies de fonctions

– Structure Personne,et ses fonctions de traitements
– Librairie personnalisée de traitement des fichiers

4
5
 NOTION DE LIBRAIRIE / PACKAGE
• Existe dans tous les langages de programmation

from tkinter import *

import java.util.* ; Egalement possible entre différents langages

mais pas dans ce cours

#include <string.h>

6
EN C : 3 TYPES DE FICHIERS

• Les modules (extension .c)

– Uniquement des fonctions
– Pas de fonction main()
• Exemple :labyrinthe.c,afficheDamier.c
• Les fichiers d’en-tête /headers (extension .h)
– Doivent être inclus dans les .c avec #include
– Contiennent des déclarations de types et les prototypes des fonctions
• Exemple :labyrinthe.h,afficheDamier.h
• Les programmes (Extension .c)
– Contiennent la fonction main() et appellent les fonctions des modules
• Exemple :jouerLabyrinthe.c

7
module1.c
#include "module1.h"
void fonction1() {
…. module1.h
} typedef int entier

entier fonction2() { void fonction1();

…. entier fonction2(); programme.c
fonction1(); #include "module1.h"
} #include "module2.h"

int main() {
…
module2.c module2.h fonction1();
#include "module2.h" typedef int entier fonction2();
void fonction3() { fonction3();
…. void fonction3(); }
} Void fonction4();

entier fonction4() {
….
}
8
PARTICULARITÉS DE #INCLUDE

• #include + < … >

– Bibliothèque standard
• #include + " … "
– Bibliothèque personnelle
• Inclusion conditionnelle
– Pour éviter les inclusions
multiples #ifndef
_MODULE1_H #define
_MODULE1_H
// definitions des types et fonctions de module1.h
#endif

9
Structures
chainées

10
Rappel sur les
structures
 Concepts
 Une structure est une collection de plusieurs variables (champs) groupées
ensemble pour un traitement commode
 Les variables d’une structure sont appelées membres et peuvent être de
n’importe quel type, par exemple des tableaux, des pointeurs ou d’autres
structures
struct Membre
{
char nom[80];
char adresse[200];
int *numero;
float amende[10];
Les étapes sont: };
 déclarer le type de la structure
 utiliser ce type pour créer autant d’instances que
désirées
 Accéder les membres des instances
12
 Déclarer les structures
 Les structures sont définies en utilisant
le mot-clé struct struct Membre
struct Date {
char nom[80];
{
char adresse[200];
int jour; int numero;
int mois; float amende[10];
! int an; struct Date emprunt;
struct Date creation;
}; };
struct Livre
{ struct Pret
{
char titre[80]; struct Livre b;
char auteur[80]; struct Date due;
struct Membre *who;
float prix; };
}; 13
 Déclarer des instances
 Une fois la structure définie, les
instances peuvent être déclarées
 Par abus de langage, on appellera
structure une instance de structure
struct Date
{
int jour;
int mois;
int an;
} hier, demain; Déclaration
avant ‘;’ .
struct Date paques;
struct Date semaine[7];
Initialisation .
struct Date nouvel_an = { 1, 1, 2022 };
14
 Des structures dans des structures
struct Date
{
int jour;
int mois;
struct Membre
int an;
{
};
char nom[80];
char adresse[200];
int numero;
float amende[10];
struct Date emprunt;
struct Date creation;
};

struct Membre m={

"Arthur Dupont",
”rue de Houdain, 9, 72000 Le Mans",
42,
{ 0.0 },
{ 0, 0, 0 },
{ 5, 2, 2001 }
}; 15
 Accéder aux membres d’une
structure
 Les membres sont accédés par le nom de l’instance,
suivi de . , suivi du nom du membre

struct Membre m;
printf("nom = %s\n", m.nom);
printf(”numéro de membre = %d\n", m.numero);

printf(”amendes: ");
for(i = 0; (i < 10) && (m.amende[i] > 0.0); i++)
printf("%.2f Euros", m.amende[i]);

printf("\nDate d’emprunt %d/%d/%d\n", m.emprunt.jour,

m.emprunt.mois, m.emprunt.an);
16
 Assignation des structures

 L’opération d’affectation = peut se faire avec

des structures
 Tous les membres de la structure sont copiés
(aussi les tableaux et les sous-structures)
struct Membre m = {
"Arthur Dupont",
.....
};

struct Membre temp;

temp = m;
17
Passer des structures comme
paramètres de fonction
 Une structure peut être passée, comme une autre
variable, par valeur ou par adresse
 Passer par valeur n’est pas toujours efficace
 Passer par adresse ne nécessite pas de recopiage

void Par_valeur(struct Membre m);

void Par_reference(struct Membre *m);

Par_valeur(m);
Par_reference(&m);
18
 Quand la structure est un pointeur !
Utiliser p->name
 L’écriture p->name est synonyme de (*p)->name,
! où p est un pointeur vers une structure

void affiche_membre (struct Membre *p)

{
printf("nom = %s\n", p->nom);
printf("adresse = %s\n", p->adresse);
printf(”numéro de membre = %d\n", p->numero);

printf("\nDate d’affiliation %d/%d/%d\n",

p->creation.jour, p->creation.mois, p->creation.an);
} 19
 Retour de structures dans une fonction

 Par valeur (recopiage) ou par référence

struct Complex add(struct Complex a, struct Complex b)
{
struct Complex result = a;
result.real_part += b.real_part;
result.imag_part += b.imag_part;

return result;
}

struct Complex c1 = { 1.0, 1.1 };

struct Complex c2 = { 2.0, 2.1 };
struct Complex c3;

c3 = add(c1, c2); /* c3 = c1 + c2 */
20
 Structures chaînées
Une structure de données est constituée de cellules chaînées les
unes aux autres par pointeurs.
Structure simplement chaînée : une cellule est un
enregistrement qui peut être déclarée comme suit:
struct Node {
int data; /* les informations */
struct Node *next; /* le lien */
};

Une Structure doublement chaînée

struct Node {
int data; /* les informations */
struct Node *next; /* lien vers le suivant */
struct Node *prev; /* lien vers le précédent */
};
21
 Structures de données dynamiques
typedef struct Node {
typedef : mot réservé, int data;
crée de nouveaux noms struct Node *next;
de types de données }cellule;
Ex :
cellule * new_node(int value)
typedef char * {
STRING;
cellule * p;
fait de STRING un synonyme
de "char * «
Portée : comme les variables. p = (cellule *)malloc(sizeof(cellule));
p->data = value;
p=new struct Node;
p->next = NULL;

return p;
}
22
TDA
23
 ETUDE DES TDA
• Type abstraits de données
– Type composite
– Abstrait :correspond à un cahier des charges qu'une structure de données doit ensuite implémenter.
• Tri par fusion :pour tableaux de structures et chacun met ce qu’il veut dans la structure tant qu’un cahier des charges est rempli !

• Types abstraits les plus utilisés sont :

– Liste chaînée
– File
– Pile
– Arbre binaire
– Dictionnaires /Tables de hachage
– …

24
 TDA
Le nom du type et le nom du type de
l’extension si c’est le cas
Un type abstrait est
Les noms des types utilisés
composé de cinq champs :
Le prototype de toutes les opérations
• Type abstrait ; - Les constructeurs (construit, initialise)
• Utilise ; - Les transformateurs (modifie l’objet)
• Opérations ; - Les observateurs (infos sur l’objet /lecture)
• Pré-conditions ;
• Axiomes. Les conditions à respecter dans les
arguments. Ensemble de définition des
opérations.

Description du comportement de chaque

opération

25
LA PILE
L I F O : LA S T I N F I R S T O U T
LES TOURS DE HANOI

14
• The Stack ADT stores arbitrary objects

• Insertions and deletions follow the last-in first-out scheme

• Main stack operations:

• push(object): inserts an element
• object pop(): removes and returns the last inserted element

• Auxiliary stack operations:

• object top(): returns the last inserted element without removing it
• int size(): returns the number of elements stored
• bool isEmpty(): indicates whether no elements are stored

1
5
1
6
1
7
Direct applications
• Page-visited history in a Web browser

• Undo sequence in a text editor

• Saving local variables when one function calls another, and this one calls another, and so on

Indirect applications
• Auxiliary data structure for algorithms

• Component of other data structures

1
8
• The C++ run-time system keeps track of the chain of active functions with a stack

• When a function is called, the run-time system pushes on the stack a frame containing:
• Local variables and return value
• Program counter, keeping track of the statement being executed

• When a function returns, its frame is popped from the stack and control is passed to the method on top of the
stack Stack space 

7
Time 
• Stack can be implemented in 2 different ways:

• Using a linked-list

• Using an array

33
OPÉRATIONS SUR LES PILES

• Constructeurs
– Créer : Pile
• Transformateurs :
– Empiler :Pile,Element  Pile
– D épiler :Pile  Pile
– D étruire :Pile  Booleen
• O bservateurs :
– sommet :Pile  Element
– estVide :Pile  Booleen

34
 PRÉ-CONDITIONS
OPERATIONS
• Constructeurs Soit P,une Pile
– Créer : Pile • P doit être non vide pour utiliser
• Transformateurs : sommet(p)
– Empiler :Pile,Element  Pile • P doit être non vide pour utiliser dépiler
– Dépiler :Pile  Pile (p)
– D étruire :Pile  Booleen
• Observateurs :
– sommet :Pile  Element
– estVide :Pile  Booleen

35
 AXIOMES
OPERATIONS
• Constructeurs Soit P,une Pile et e,f des Elements
• Créer : Pile
• Transformateurs : 1. Sommet(empiler(p,e)) = e
• Empiler :Pile,Element  Pile
• Dépiler :Pile  Pile 2. Depiler(empiler(p,e)) = p
• Détruire :Pile  Booleen
• Observateurs : 3. estVide(créer()) = vrai
• sommet :Pile  Element
• estVide :Pile  Booleen
4. estVide (empiler(p,e)) = faux
PRE-CONDITIONS
Soit P,une Pile
• P doit être non vide pour utiliser sommet(p)
• P doit être non vide pour utiliser dépiler (p)

36
 TYPES UTILISÉS
OPERATIONS Types utilisés :
• Constructeurs Booléen,
• Créer : Pile
Element
• Transformateurs :
• Empiler :Pile,Element  Pile
• Dépiler :Pile  Pile
• Détruire :Pile  Booleen
• Observateurs :
• sommet :Pile  Element
AXIOMES
• estVide :Pile  Booleen
Soit P,une Pile et e,f des Elements
PRE-CONDITIONS 1. Sommet(empiler(p,e)) = e
Soit P,une Pile 2. Depiler(empiler(p,e)) = p
• P doit être non vide pour utiliser sommet(p) 3. estVide(créer()) = vrai
• P doit être non vide pour utiliser dépiler (p) 4. estVide (empiler(p,e)) = faux

37
REPRÉSENTATION DE LA STRUCTURE
DE DONNÉES

38
FINALEMENT EN C

struct element { typedef struct _stack{

struct element * next; P_ELT top;
void *value; int size;
} } STACK;

typedef struct element ELT;

typedef struct element *
P_ELT;

39
 LES PROTOTYPES EN C
STACK* stack_create (); /* create an empty stack */
int stack_is_empty(STACK *s); /* returns 1 if empty, 0 otherwise */
int stack_push(STACK *s, const void *value); /* Add an element on top
of the stack */
int stack_pop(STACK *s, void **value); /* remove the last cell of the
stack and return its value */

int stack_delete(STACK *s); /*destroy the stack*/

void * stack_top_value(STACK *s); /*Return the top value of the stack*/

40
UTILISATION DES PILES

• Taches d’annulation et de retour en arrière

• Analyse syntaxique :vérifier les séquences de ( [ { } ] )
• Calculs en notation polonaise inversée

41
TD : A VOS CRAYONS

• Donnez les algos ou le code C des fonctions de manipulation d’une pile

42
LES LISTES
UNE LISTE

• Une structure de données

• Regrouper des données de manière à pouvoir y accéder
librement
• Une liste est suite finie d’éléments
• Liste homogène :tous les éléments sont de même type
• Liste hétérogène :les éléments sont de types hétérogènes

44
COMPRENDRE LE BESOIN

• Stocker les différents éléments de la liste de course suivante :

45
COMPRENDRE LE BESOIN

• Stocker les différents éléments de la liste de course suivante :

– Lait /œufs /pates /Yaourts /légumes /Fruits /Céréales /Eau /Dentifrice
• Vous commencez vos courses par les légumes,puis les fruits que vous
pouvez donc retirer de la liste
• Puis :l’eau
• Puis :LesYaourths et les œufs
•…

46
COMPRENDRE LE BESOIN

• Stockage de multiples éléments dans un tableau

• Difficultés :
– Ajout /suppression d’éléments oblige à bouger tous les autres éléments

47
48
LE TDA LISTE
OPÉRATIONS SUR LES LISTES
• Constructeurs
– Créer : liste
• Transformateurs :
– Insérer :Liste,Element,Place  Liste
– Retirer :Liste,Place  Liste
– Détruire :Pile  Booleen
• Observateurs :
– Taille :Liste  Entier
– estVide :Liste  Booleen
– Premier :Liste  Element
– Dernier :Liste  Element
– Prochain :Liste,Element  Element
– Précédent :Liste,Element  Element
– Cherche :Liste,Element  Entier
50
PRÉ-CONDITIONS

Soit L,une Liste

• L doit être non vide pour utiliser retirer(p)
• L doit être non vide pour utiliser premier(L)
• L doit être non vide pour utiliser dernier(L)
• …

51
AXIOMES
Soit L une liste,n un rang valide et e,f des
Elements
1. Retirer(insérer(l,e,n),n) = l,e
2. estVide(créer()) = vrai
3. estVide (inserer(l,e,n)) = faux

52
TYPES UTILISÉS

Booléen,
Element
Entier

53
REPRÉSENTATION DE LA STRUCTURE
DE DONNÉES

MaListe

54
MARQUER LA FIN DE LISTE

• Fin de la chaine quand l’élément suivant est N ULL

• L’adresse de l’élément suivant est l’adresse de l’élément lui-même

• La liste est définie par un pointeur de début et un pointeur de fin.Le pointeur de fin désigne
toujours le dernier élément de la liste, il sert de sentinelle.La fin est connue si l’élément
suivant est le dernier.

55
FINALEMENT EN C

typedef struct { typedef struct {

simple_cell * next; simple_cell* first;
void *data; int size;
} simple_cell ; } simple_list;

56
QUELQUES PROTOTYPES EN C
• simple_list* simple_create() qui crée une structure liste et l’initialise (size = 0)
• int simple_is_empty(simple_list* LIST) qui renvoie 1 si liste vide et 0 sinon
• int simple_add(simple_list* LIST, void* value,int position) qui ajoute les
données stockées à l’adresse value dans une nouvelle cellule qui est ajoutée en position «
position » dans la liste. Si la liste n’est pas assez longue pour utiliser cette position alors la
fonction renvoie 1
• int simple_remove(simple_list *LIST, void **data, int position) qui supprime un
élément de la liste et renvoie l’adresse de ses données dans *data
• int simple_find_previous(simple_list *LIST, void *data) qui recherche dans la liste l’élément
précédent celui contenant les données stockées à l’adresse data

57
AMÉLIORATIONS

• Long et non optimal pour retirer un élément en fin de liste

58
LISTES DOUBLEMENT CHAINÉES

59
LISTES CIRCULAIRES

60
61
• A linked list is a fundamentally different way of storing collections

• A linked list is a series of connected nodes, where each node is a data structure

• Each node contains:

• One or more members that represent data
• A pointer (link) to the next node in the list

Node

Linked List

• Elements are NOT stored in contiguous memory locations

62
• Data collection

• No fixed size
• can easily grow or shrink in size during the program run time

• Space overhead
• Each element must store an additional pointer
• Size = length * sizeof(element) + length * sizeof(pointer)

• Elements of the list are NOT stored in contiguous memory locations

• No Easy access to the i-th element of the list

• Need to traverse the list starting from the head of the list and passing by all previous nodes

-- No fast element access

++ Possibility of resizing
63
64
To implement a linked list, we need two C++ classes:

• One class to implement the node

• One class to implement the list

Object of the
Linked List class

An example of a linked list Object of

having a single pointer pointing the Node
the first node of the list class

65
THIS I S ANOTHER WAY TO IMPLEMENT A
LINKED LIST
Object of the
Linked List class

An example of a linked list having: Object of

• One pointer pointing to the first node of the list the Node
• One pointer pointing to the last node of the list class

5
One more way to implement a linked list

Object of
Object of the the Node
We are going to Linked List class class
implement this
example

An example of a linked list having:

• One pointer pointing to the first node of the list
• One pointer pointing to the last node of the list
• One variable saving the size of the list
54
LINKED LIST
NOD
E

Since each node has a single

pointer, this kind of lists is
called Singly Linked List

5
 LIST BEFORE ADDING THE NEW
NODE

Steps: Implementation:
Allocate new node

SLLNode* newNode = new SLLNode(data, NULL);

Insert new element

Have next of new node pointing to newNode->next = head;

old head

head = newNode;
Update head to point to new node

head = new SLLNode(data, head);

5
 LIST BEFORE ADDING THE
NEW NODE
Steps: Implementation:
Allocate a new node

Insert new data

SLLNode* newNode = new SLLNode(data, NULL);

Have next of new node pointing to NULL

Have next of old tail pointing to new node tail->next = newNode;

Update tail to point to new node tail = newNode;

5
LIST BEFORE REMOVING THE NEW
NODE

Steps: Implementation:

Update head to point to its next SLLNode* oldHead = head;

(2nd node in the list) head = head->next;

Delete the old head delete oldHead;

5
 STEPS: Implementation:
Create a temporary pointer SLLNode* tmp = head;
pointing to the head

while (tmp->next != tail) {

Traverse the list and stop at tmp = tmp->next;
the predecessor of the tail }

Delete old tail delete tail;

Have tail point to the temporary node tail = tmp;

Update tail to point to NULL tail->next = NULL;

5
Removing at the tail of a singly linked list is not efficient!

There is no constant-time way to update the tail to point to the previous node

We have to traverse the whole list in order to have a pointer to the predecessor of the tail

60
 STEPS: Allocate a new node Implementation:
SLLNode* newNode = new SLLNode(data, NULL);
Insert new data

Create a temporary pointer pointing to SLLNode* tmp = head;

the head

int i = 0;
while (i < index - 1) {
Traverse the list and stop at (index – 1) tmp = tmp->next;
i++;
}

Update the next of new node

to point to the next of the node newNode->next = tmp->next;
at (index – 1)

Update next of node at (index – 1)

tmp->next = newNode;
to point to the new node

6
75
• A doubly linked list can be traversed forward and backward

• Each node contains:

• One or more members that represent data
• A pointer (link) to the next node in the list
• A pointer (link) to the previous node in the list

76
 LIST BEFORE INSERTING THE NEW
NODE
Allocate new node

Insert new data

Have next of the new node tail = new DLLNode(data, NULL, tail);
point to NULL

Have previous of new

node point to old tail

Have tail point to new

node

Have next of old tail point tail->prev->next = tail;

to new tail 39
LIST BEFORE REMOVING THE NEW
NODE

Steps: Implementation:

Have tail point to the previous of the tail = tail->prev;

old tail

Delete old tail delete tail->next;

Have next of tail point to NULL tail->next = NULL;

6
66
A LINKED LIST IN WHICH THE LAST NODE POINTS TO
THE FIRST NODE

In a circular linked list with more than one node, it is convenient to make the pointer first point to the last node of the list

Then by using first you can access both the first and the last node of the list

For example, first points to the last node and first->next points to the first node

We can traverse the whole list by starting from any node (we just need to stop when the first visited node is visited again)

6
LES FILES
FIFO
COMPRENDRE LE BESOIN

• https://www.youtube.com/watch?v=qxLsyFuR3dY

82
• The Queue ADT stores arbitrary objects

• Insertions and deletions follow the first-in first-out scheme

• Insertions are at the rear of the queue and removals are at the front of the queue

• Main queue operations:

• enqueue(object): inserts an element at the end of the queue
• object dequeue(): removes and returns the element at the front of the queue

• Auxiliary queue operations:

• object front(): returns the element at the front without removing it
• int size(): returns the number of elements stored
• bool isEmpty(): indicates whether no elements are stored

83
84
85
Direct applications
• Waiting lists, bureaucracy

• Access to shared resources (e.g., printer)

• Multiprogramming

Indirect applications
• Auxiliary data structure for algorithms

• Component of other data structures

86
Example of a queue: Processes waiting their turn to be execute

87
 A

Example of a queue: Shared printer Example of a queue: Packet forwarding by routers

88
• Queue can be implemented in 2 different ways:

• Using a linked-list

• Using an array

89
UNE FILE

• Une file est une liste linéaire d’objets où les consultations et les
suppressions se font du même côté, les insertions se font de
l’autre.
• Premier arrivé, premier servi = FIFO :First In First Out

90
UNE FILE

• Une file est une liste linéaire d’objets où les consultations et les
suppressions se font du même côté, les insertions se font de
l’autre.
• Premier arrivé, premier servi = FIFO :First In First Out
Enfiler /
Enqueue Dernier Premier
Défiler /dequeue

91
LE TDA FILE
OPÉRATIONS SUR LES FILES

• Constructeurs
– Créer : File
• Transformateurs :
– enfiler :File,Element  File
– défiler :File  Element x File
– détruire :File  Booleen

• Observateurs :
– estVide :File  Booleen

93
PRÉ-CONDITIONS

• Constructeurs Soit F,une File

– Créer : File • F doit être non vide pour utiliser défiler(F)

• Transformateurs :
– enfiler :File,Element  File
– défiler :File  Element x File
– détruire :File  Booleen

• Observateurs :
– estVide :File  Booleen

94
AXIOMES
• Constructeurs
– Créer : File Soit F une File,e un Element
• Transformateurs : 1. estVide(créer()) = vrai
– enfiler :File,Element  File 2. estVide (enfiler(f,e)) = faux
– défiler :File  Element x File
– détruire :File  Booleen
• Observateurs :
– estVide :File  Booleen

Soit F,une File

• F doit être non vide pour utiliser défiler(F)
95
TYPES UTILISÉS
• Constructeurs
– Créer : File
Booléen,
• Transformateurs : Element
– enfiler :File,Element  File
– défiler :File  Element x File
– détruire :File  Booleen
• Observateurs :
Soit F une File,e un Elements
– estVide :File  Booleen
1. défiler(enfiler(f,e)) = f
2. estVide(créer()) = vrai
Soit F,une File 3. estVide (enfiler(f,e)) = faux
• F doit être non vide pour utiliser défiler(F)
96
REPRÉSENTATION DE LA STRUCTURE
DE DONNÉES

Tête de file Queue de file

97
IMPLÉMENTATION
98
IMPLÉMENTATION COMME LISTE
CHAINÉE
• Implémentation comme une liste chaînée,
• Avec des restrictions limitant l’insertion et le retrait

Tête de file Queue de file

99
IMPLÉMENTATION COMME LISTE
CHAINÉE
• Si on garde une liste chaînée,l’ajout va être compliqué,puisqu’il faudra à chaque fois parcourir
toute la file …
 ajouter un pointeur vers la fin de la file

Tête de file Queue de file

10
0
FINALEMENT EN C

typedef struct { typedef struct {

cell * next; cell* first;
void *value; cell* last;
} cell ; int size;
} queue;

10
1
LES PROTOTYPES EN C
//create an empty queue
Q UEUE* queue_create ();
//returns 1 if empty,0 otherwise
int queue_is_empty(Q UEUE *q);
//Add an element at the back of the queue
int queue_enqueue(QUEUE *q, const void *value);
//remove the first cell of the queue and return its value
int queue_dequeue(Q UEUE *q, void **value);
//destroy the queue
int queue_destroy(Q UEUE *q);
//return the size of the queue
int queue_size(Q UEUE *q);
10
2
UTILISATION DES FILE

• Dès que l’on a besoin de traiter une file d’attente

– File d’attente d’impressions,
– D e processus à exécuter

10
3
AMÉLIORATIONS

10
4
FILE D’ATTENTE AVEC PRIORITÉS

2 solutions
• 1 cellule = 1 élement + 1 priorité
– Dans ce cas,on enfile selon le niveau de priorité
– On défile l’élément qui a la plus forte priorité
liste doublement chainée pour faciliter les déplacements

• 1 liste de files d’attentes :

– Chaque élément de la liste principale, est une liste d’attente d’une priorité donnée.

10
5
FILE AVEC PRIORITÉS – SOLUTION 1

• L’insertion doit respecter l’ordre de priorité

• Défiler,renvoie l’élément de priorité la plus forte (celui en tête de file)

p0 > p1 > p2 > p3

10
6
IMPLÉMENTATION EN C

10
7
FILE AVEC PRIORITÉS – SOLUTION 2
P0

NULL
4 4 NULL

P1

2 NULL

P2

1 NULL

P3
NULL

3 NULL
10
8