Cours_structure_donnees_beamer_pandry.pdf

STRUCTURES DE DONNÉES
Ghislain PANDRY
MP2I
Mars 2025
Ghislain PANDRY (ESATIC) STRUCTURES DE DONNÉES Mars 2025 1 / 33

Structures de données
Définition
Méthode pour stocker et organiser les données pour en faciliter l’accès et la
modification.
Une structure de données regroupe :
▷ un certain nombre de données à gérer, et
▷ un ensemble d’opérations pouvant être appliquées à ces données.
Dans la plupart des cas, il existe :
▷ plusieurs manières de représenter les données et
▷ différents algorithmes de manipulation.
On distingue généralement l’interface des structures de leur
implémentation.

Structures de données
Définition
Une structure de données est une manière d’organiser et de stocker l’information.
Objectif
▷ Faciliter l’accès ou organiser les données pour des besoins spécifiques.
Interface des structures
Une structure de données possède une interface qui regroupe un ensemble de
procédures permettant :
▷ d’ajouter, effacer, accéder, et réorganiser les données.
Stockage des données
Une structure de données conserve des données et éventuellement des
méta-données.
▷ Exemple : Un tas utilise un tableau pour stocker les clés et une variable
A.heap-size pour retenir le nombre d’éléments.
Type de données abstrait (TDA)

Structures de données et algorithmes en pratique
La résolution de problèmes algorithmiques requiert presque toujours la
combinaison de structures de données et d’algorithmes sophistiqués pour la
gestion et la recherche dans ces structures.
D’autant plus vrai qu’on a à traiter des volumes de données importants.
Quelques exemples de problèmes réels :
▷ Routage dans les réseaux informatiques
▷ Moteurs de recherche
▷ Alignement de séquences ADN en bio-informatique

Opérations standards sur les structures
Types d’opérations
Deux types : opérations de recherche/accès aux données et opérations de
modifications.
Recherche : exemples
▷ SEARCH(S, k) : retourne un pointeur x vers un élément dans S tel que
x.key = k, ou NIL si un tel élément n’appartient pas à S.
▷ MINIMUM(S), MAXIMUM(S) : retourne un pointeur vers l’élément avec
la plus petite (resp. grande) clé.
▷ SUCCESSOR(S, x), PREDECESSOR(S, x) : retourne un pointeur vers
l’élément tout juste plus grand (resp. petit) que x dans S, NIL si x est le
maximum (resp. minimum).
Modification : exemples
▷ INSERT(S, x) : insère l’élément x dans S.
▷ DELETE(S, x) : retire l’élément x de S.

Définition 1
Définition
Un objet est un conteneur s’il peut contenir plusieurs objets.
Un conteneur est une suites s’il contient une collection ordonnée d’objets
qui sont accessibles par leur position dans la séquence qu’on désigne par
index.
Un tableau est une structure de données qui est un conteneur et une
séquence. Il permet de stocker plusieurs éléments dans une seule variable et
d’y accéder par leur index.

Définition d’une séquence
Définition
Étant donné
un ensemble de valeurs E
un ensemble fini totalement ordonné I d’éléments appelés indices,
Une séquence sur E est une application de I dans E :
s : I → E
À chaque i de I correspond un élément de E : i → si
I est souvent N ou une partie de N, mais ce peut être un type scalaire différent du
réel car un tel type a toutes les propriétés de I .
L’énumération des éléments de la séquence induit un ordre total appelé ordre
induit par la séquence, qui n’est autre que l’ordre des rangs, à ne pas confondre
avec l’ordre éventuel sur E.

Séquence triée
Définition
Étant donné un ensemble E totalement ordonné par la relation ≤, on dit qu’on a
une séquence triée lorsque l’ordre induit par la séquence est compatible avec
l’ordre sur E :
∀(i, j) ∈ I , i ≤ j ⇐⇒ si ≤ sj
Trier une séquence s, c’est trouver une séquence triée s′
formée des mêmes
éléments que s.
Trier une séquence n’est possible que s’il existe une relation d’ordre sur E.

Tableau et implantation d’une séquence
Définition
Un tableau permet l’implantation d’une séquence. Le tableau est le contenant de
la séquence, comme une variable élémentaire est le contenant d’une valeur scalaire.
Tableau à une dimension
Un tableau à une dimension (appelé aussi vecteur) est une structure de données
formée de cellules contiguës et d’accès direct. L’accès direct signifie que l’on peut
obtenir le contenu d’une cellule sans qu’il soit nécessaire de connaı̂tre le contenu
des cellules précédentes du tableau.
Définition d’un tableau
Pour définir un tableau, il faut préciser l’identificateur du tableau, le type de I et
le type de E.

Tableau et implantation d’une séquence
Définition
Un tableau est une structure de donnée T qui permet de stocker un certain
nombre d’éléments T[i] repérés par un index i. Les tableaux vérifient
généralement les propriétés suivantes :
■ tous les éléments ont le même type de base ;
■ le nombre d’éléments stockés est fixé ;
■ l’accès et la modification de l’élément numéro i est en temps constant Θ(1),
indépendant de i et du nombre d’éléments, le tableau.

Un tableau en mémoire
Définition
Dans le tableau, tous les éléments ont la même taille mémoire.
Nombre d’éléments : n, taille d’un élément t :
T[0] T[1] T[2] . . . T[n-1]
On suppose que le tableau commence à l’adresse d :
■ T[0] occupe les cases d à d + t − 1 ;
■ T[1] occupe les cases d + t à d + 2t − 1 ;
■ T[i] occupe les cases d + it à d + (i + 1)t − 1 ;
■ Le tableau entier occupe les cases d à d + nt − 1.

Déclaration d’un tableau
La déclaration d’un tableau permet d’associer à un nom une zone mémoire
composée d’un certain nombre de cases mémoires de même type.
Syntaxe :
Variable identificateur : tableau[indice min .. indice max] de type
Ou bien
Variable identificateur : tableau[taille] de type
Notes :
Le premier élément d’un tableau porte l’indice zéro ou l’indice 1 selon les
langages.
La valeur d’un indice doit être un nombre entier.
La valeur d’un indice doit être inférieure ou égale au nombre d’éléments du
tableau. Par exemple, avec le tableau tab[1..20], il est impossible d’écrire
tab[0] et tab[21]. Ces expressions font référence à des éléments qui
n’existent pas.

Déclaration d’un tableau
Exemple :
L’instruction suivante déclare un tableau de 30 éléments de type réel :
Variable Note : tableau[1..30] de Réels
Note :
Note : c’est le nom du tableau (identificateur).
1 : c’est l’indice du premier élément du tableau.
30 : c’est l’indice du dernier élément du tableau (nombre d’éléments du
tableau).

Un tableau en mémoire
Soit la déclaration : T :Tableau[4] de entier ;
Si on fait correspondre l’adresse @1 au tableau, alors l’adresse d’un élément T[I]
est calculée comme suit :
@ = N × (I − 1) + @1
où N est le nombre d’emplacements réservés pour un élément du tableau (exemple
pour les entiers N = 2).
Remarque : Si les indices commencent à 0, alors :
@ = N × I + @1
Représentation mémoire :

Séquence doublement indicée
Définition
Un ensemble de valeurs E
Deux ensembles finis I et J totalement ordonnés
Une séquence sur E est une application de I × J dans E :
s : I × J → E
À chaque couple (i, j) dans lequel i est élément de I et j est élément de J,
correspond un élément de E :
(i, j) → si,j
Une séquence doublement indicée sert à modéliser ce qu’on appelle une table à
double entrée. Elle est représentée souvent par une matrice.

Implémentation d’une séquence doublement indicée par
tableau à deux dimensions
Définition
Un tableau à deux dimensions est une structure de données permettant
l’implantation d’une séquence doublement indicée. Pour définir un tel tableau, il
faut préciser :
L’identificateur du tableau
Le type de I et de J
Le type de E

Tableaux à Deux Dimensions
Exemple d’un tableau à deux dimensions :
Etudiant 1 Etudiant 2 Etudiant 3 Etudiant 4
Informatique 12 13 9 10
Comptabilité 12.5 14 12 11
Mathématiques 15 12 10 13
Les tableaux à deux dimensions se représentent comme une matrice ayant un
certain nombre de lignes (première dimension) et un certain nombre de colonnes
(seconde dimension).

Tableaux à Deux Dimensions
Représentation schématique d’un tableau 3x4 :
12 13 9 10
12.5 14 12 11
15 12 10 13
1
2
3
Indices du tableau Contenu du tableau

Déclaration d’un tableau à deux dimensions
Syntaxe :
Variable identificateur : tableau[1..nb lignes, 1..nb colonnes] de type
Ou bien
Variable identificateur : tableau[nb lignes, nb colonnes] de type
Exemple :
L’instruction suivante déclare un tableau Note de type réel à deux dimensions
composé de 3 lignes et de 4 colonnes :
Variable Note : tableau[1..3, 1..4] de réels

Allocation statique
Définition
Allocation de mémoire effectuée lors de l’exécution mais dont la taille est
prévue lors de la compilation
▶ À chaque type de données correspond une taille mémoire et une façon de
représenter l’information
▶ À chaque variable ou paramètre formel déclaré correspond un espace mémoire
dont la taille est fonction du type
Le compilateur ajoute donc automatiquement du code pour réserver de
l’espace mémoire avant utilisation (au niveau de la déclaration) et pour
libérer si besoin est (dans la pile)

Allocation dynamique
Définition
Allocation de mémoire effectuée lors de l’exécution mais dont la taille n’est
pas obligatoirement prévue lors de la compilation
▶ Allocation qui se fait uniquement dans le tas
▶ Cette allocation est à la charge du programmeur, il lui faut donc :
⋆ une procédure permettant de réserver une zone mémoire (allouer)
⋆ une procédure permettant de libérer une zone mémoire (libérer)
⋆ une variable (et donc un type) permettant de référencer cette zone mémoire
allouée

Le problème 1 / 2
Contexte
Lorsque l’on veut stocker en mémoire n éléments de même type, on utilise
jusqu’à présent les tableaux.
Les tableaux sont généralement des allocations statiques (la taille du tableau
est définie à la compilation), on ne peut pas l’adapter au contexte. Le fait de
réserver MAX éléments :
▶ consomme beaucoup de mémoire si peu d’éléments réellement utilisés
(n ≪ MAX )
▶ pose problème si on a besoin de plus de MAX éléments à stocker (n > MAX )
Il faudrait pouvoir stocker en mémoire autant de données dont on a besoin et
pas plus.
Mais ce nombre de données ne peut être déterminé à la compilation, il ne
peut être déterminé qu’à l’exécution.

Le problème 2 / 2
Comment les concevoir ?
Il faut donc que la mémoire soit réservée à l’exécution ⇒ besoin d’allocations
dynamiques.
Mais il faut pouvoir référencer ces allocations dynamiques ⇒ besoins de
pointeurs (les pointeurs sont des variables donc allocation statique).
Ainsi le nombre de pointeurs est fonction du nombre d’éléments que l’on veut
stocker, ce qui est contradictoire avec notre objectif.
Il faut donc que les futurs espaces mémoires alloués ne soient pas référencés
par des variables mais par les espaces mémoires déjà alloués.
Ainsi les espaces mémoires déjà alloués stockent l’information à
réellement stocker et également une référence vers les autres espaces
mémoires alloués ou à allouer (définition récursive).

Pointeur et Opérateurs sur les pointeurs
Pointeur
On nomme un pointeur p une variable permettant de référencer une zone
mémoire permettant de stocker une information de type T.
Le type de p est nommé pointeur sur T . Il est noté T̂.
Lorsqu’une variable ne pointe sur aucune zone mémoire, il faut l’initialiser
avec la valeur NIL( Not In List).
Opérateurs sur les pointeurs
ˆopérateur unaire (opérande à gauche de l’opérateur) permettant de
déréférencer un pointeur (accéder à la valeur de la zone mémoire pointée).
@ opérateur unaire (opérande à droite de l’opérateur) permettant d’obtenir
un pointeur sur une variable.

Mémoire et stockage des variables
Toute variable manipulée dans un programme est stockée quelque part en
mémoire centrale.
La mémoire peut être assimilée à un“tableau”dont chaque élément est
identifié par une ‘adresse’.
Pour retrouver une variable, il suffit, donc, de connaı̂tre l’adresse de
l’élément-mémoire où elle est stockée.
C’est le compilateur qui fait le lien entre l’identificateur d’une variable et son
adresse en mémoire.
Il peut être cependant plus intéressant de décrire une variable non plus par
son identificateur mais directement par son adresse !

Lvalue : adresse et valeur
Définition
On appelle Lvalue (left value) toute expression du langage pouvant être placé à
gauche d’un opérateur d’affectation.
Caractérisation
Une Lvalue est caractérisée par :
▶ son adresse : i.e., l’adresse mémoire à partir de laquelle l’objet est stocké ;
▶ sa valeur : i.e., ce qui est stocké à cette adresse.
Une variable est un exemple concret de Lvalue.

Variables et Adresses
Soit l’algorithme suivant :
Algorithme Exemple ;
Var
X, Y : entier ;
M : réel ;
Début
Écrire(”Donner deux entiers : ”
) ;
Lire(X, Y) ;
M ← (X+Y)/2 ;
Écrire(”Moyenne =”, M) ;
Fin.
Dans la partie déclaration de cet algorithme, on a déclaré deux variables
entières X et Y et une variable réelle M.
Donc au début de l’exécution :
on va réserver deux emplacements mémoires nommés X et Y qui vont
recevoir des entiers : donc de même taille.
Et un emplacement mémoire nommé M qui va recevoir un réel donc de
taille plus grande.

Variables et Adresses
X Y
M

Problème de réservation statique
Supposons que vous êtes un groupe de 10 étudiants, et vous voulez
organiser un voyage ensemble.
Donc une semaine avant le départ, vous allez faire une réservation d’hôtel pour 10
personnes que vous payez à l’avance.
Le jour J, 4 étudiants se sont excusés, ils ont des empêchements majeurs. Les 6
restants décident de partir.
Mais malheureusement, la direction de l’hôtel ne va pas rembourser les frais de
réservation des 4.
C’est le problème qui se pose pour toute réservation à l’avance (Statique :
l’adresse de l’hôtel est connue avant le départ).
En algorithmique, on a vu ce type de problème dans la déclaration des tableaux.
On déclare un tableau de taille Max, mais à l’exécution, suivant la taille exacte du
tableau (le fameux N), il se peut que la moitié du tableau ne sera pas utilisée.
Mais l’espace est réservé durant toute l’exécution, et donc la moitié de l’espace
est réservé pour rien ! ! ! !

Réservation Dynamique
Au lieu de faire une réservation à l’avance, le groupe décide de chercher un
hôtel une fois arrivé à destination.
Dans ce cas, le jour J, les 6 étudiants vont chercher un hébergement pour 6
seulement (nombre exact) et non pas pour 10. Et donc ils vont payer pour 6
aussi et non pas pour 10.
Oui, mais dans ce cas on risque de ne pas trouver 6 places dans le même
hôtel ! ! !
Effectivement, il se peut qu’ils vont se répartir sur deux, trois ou à la limite 6
hôtels.
Par exemple :
1ere Hôtel : 2 Places, 2eme Hôtel : 3 Places, 3eme Hôtel : 1 Place
Donc ils seront tous hébergés, mais à des endroits (Adresses) différents.
Et ces adresses ne sont connues qu’à l’arrivée à la destination (A l’exécution).
Et ainsi, on gagne les frais de réservation de 4 personnes.
C’est ce qu’on appelle une réservation DYNAMIQUE :
l’adresse n’est pas connue à l’avance mais à l’exécution.

Relation entre Pointeurs et Réservation
Ok, tout ça est bon, mais on ne voit toujours pas la relation avec les
POINTEURS.
C’est parce qu’on n’a pas tout vu sur les pointeurs.
Et bien, lorsqu’on déclare un pointeur dans un algorithme, on ne fait pas de
réservation d’emplacements mémoire, c’est juste une prévision : on déclare qu’on
aura besoin d’un espace pour un type donné.
La seule réservation STATIQUE qu’on fait est un emplacement (une adresse
statique pour le pointeur) qui va contenir l’adresse de la variable au moment de
l’exécution (adresse DYNAMIQUE pour la variable pointé).
Mais vous avez toujours dit qu’on ne peut pas faire de réservation pendant
l’exécution.
On ne POUVAIT pas.
Mais, maintenant, avec les pointeurs ON PEUT.

Tableau dynamique
Les tableaux définis jusqu’ici sont dits statiques, car il faut qu’au moment de
l’écriture du programme le programmeur décide de la taille maximale que pourra
atteindre le tableau. Si le programmeur donne une taille très grande alors qu’il n’a
pas besoin d’une petite taille, dans ce cas le programme consomme trop de
mémoire. Dans certaines situations, on ne peut pas savoir la taille du tableau dans
la phase de programmation.
Les tableaux dynamiques sont des tableaux dont la taille n’est définie que lors de
l’exécution. Pour créer un tableau dynamique, il suffit de lui affecter une taille vide.
Syntaxe :
Variable identificateur : tableau [] de type
Comme un tableau dynamique ne possède pas de taille prédéfinie, il convient de
redimensionner le tableau avant de pouvoir s’en servir.
Syntaxe :
Redimensionner identificateur[N]

Tableaux unidimensionnels dynamiques
Un tableau unidimensionnel dynamique ou vecteur est une séquence de
données du même type ; la taille de la séquence est variable (elle peut changer au
cours de l’exécution du programme).
Il est possible d’accéder à chaque élément du vecteur par son index
0 1 2 3 4 5 6 7 8
12 14 16 09 11 10 13 17 11
Le vecteur avec un élément supplémentaire ajouté en fin de séquence

Cours_structure_donnees_beamer_pandry.pdf

Contenu connexe

Similaire à Cours_structure_donnees_beamer_pandry.pdf

Plus de ghislainpandry2

Dernier

Cours_structure_donnees_beamer_pandry.pdf