Modul
Modul
Modul
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
4
5
NOTION DE LIBRAIRIE / PACKAGE
• Existe dans tous les langages de programmation
#include <string.h>
6
EN C : 3 TYPES DE FICHIERS
7
module1.c
#include "module1.h"
void fonction1() {
…. module1.h
} typedef int entier
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
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;
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]);
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
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
return result;
}
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 */
};
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 !
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.
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
1
5
1
6
1
7
Direct applications
• Page-visited history in a Web browser
• Saving local variables when one function calls another, and this one calls another, and so on
Indirect applications
• Auxiliary data structure for algorithms
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
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 */
40
UTILISATION DES PILES
41
TD : A VOS CRAYONS
42
LES LISTES
UNE LISTE
44
COMPRENDRE LE BESOIN
45
COMPRENDRE LE BESOIN
46
COMPRENDRE LE BESOIN
47
48
LE TDA LISTE
OPÉRATIONS SUR LES LISTES
• Constructeurs • Observateurs :
– Créer : liste – Taille :Liste Entier
• Transformateurs : – estVide :Liste Booleen
– Insérer :Liste,Element,Place Liste – Premier :Liste Element
– Retirer :Liste,Place Liste – Dernier :Liste Element
– Détruire :Pile Booleen – Prochain :Liste,Element Element
– Précédent :Liste,Element Element
– Cherche :Liste,Element Entier
50
PRÉ-CONDITIONS
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
• 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
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
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
Node
Linked List
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)
Object of the
Linked List class
65
THIS I S ANOTHER WAY TO IMPLEMENT A
LINKED LIST
Object of the
Linked 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
5
LIST BEFORE ADDING THE NEW
NODE
Steps: Implementation:
Allocate new node
head = newNode;
Update head to point to new node
5
LIST BEFORE ADDING THE
NEW NODE
Steps: Implementation:
Allocate a new node
5
LIST BEFORE REMOVING THE NEW
NODE
Steps: Implementation:
5
STEPS: Implementation:
Create a temporary pointer SLLNode* tmp = head;
pointing to the head
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
int i = 0;
while (i < index - 1) {
Traverse the list and stop at (index – 1) tmp = tmp->next;
i++;
}
6
75
• A doubly linked list can be traversed forward and backward
76
LIST BEFORE INSERTING THE NEW
NODE
Allocate new node
Have next of the new node tail = new DLLNode(data, NULL, tail);
point to NULL
Steps: Implementation:
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 are at the rear of the queue and removals are at the front of the queue
83
84
85
Direct applications
• Waiting lists, bureaucracy
• Multiprogramming
Indirect applications
• Auxiliary data structure for algorithms
86
Example of a queue: Processes waiting their turn to be execute
87
A
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
• 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
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
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
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
10
5
FILE AVEC PRIORITÉS – SOLUTION 1
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