STRUCTURES DE DONNÉES STRUCTURES DE DONNÉES

Centre CPGE TSI - Safi 2010/2011
j. BAKKAS
Algorithmique et programmation :
STRUCTURES DE DONNÉES
STRUCTURES DE DONNÉESSTRUCTURES DE DONNÉES
STRUCTURES DE DONNÉES
A. Structure et enregistrement
1) Définition et rôle des structures de données en programmation
1.1) Définition :
En informatique, une structure de données est une structure logique destinée à contenir des données,
afin de leur donner une organisation permettant de simplifier leur traitement. Une structure de
données implémente concrètement un type abstrait.
1.2) Objectifs de l’utilisation des structures de données
Exemple de la vie quotidienne : les numéros de téléphone peuvent être présentés par nom, par
profession (comme les Pages jaunes), par numéro téléphonique (comme les annuaires destinés au
télémarketing), par rue ou une combinaison quelconque de ces classements. À chaque usage
correspondra une structure d'annuaire appropriée.
En organisant d'une certaine manière les données, on permet un traitement automatique de ces
dernières plus efficace et plus rapide.
1.3) Exemples de structures de données
Différentes structures de données existent pour des données différentes ou répondant à des
contraintes algorithmiques différentes :
Exemples:
Variable, Tableau (à une et à deux dimension), enregistrements, Listes chainées, Piles, Files,
les arbres, les graphes,...
2) Les enregistrements
Jusqu'à présent, nous n'avons utilisé que des types primitifs (caractères, entiers, réels, chaînes) et
des tableaux de types primitifs. Mais nous pouvons créer nos propres types puis déclarer des
variables ou des tableaux d'éléments de ce type.
2.1) Définition :
Les enregistrements sont des structures de données dont les éléments peuvent être de type
différent. Contrairement aux tableaux qui sont des structures de données dont tous les éléments
sont de même type,
Pour créer des enregistrements, il faut déclarer un nouveau type (type structuré), basé sur d'autres
types existants.
Après avoir défini un type structuré, on peut l'utiliser comme un type normal en déclarant une ou
plusieurs variables de ce type.
Les variables de type structuré sont appelées enregistrements.
Les éléments qui composent un enregistrement sont appelés champs
2.2) Déclaration
Type
Structure nom_type
nom_champ1: type_champ1
…
nom_champN: type_champN
FinStruct

Centre CPGE TSI - Safi 2010/2011
j. BAKKAS
Exemple Type
Structure Tpersonne
nom : chaîne
adresse : chaîne
âge : entier
FinStruct
Une fois qu'on a défini un type structuré, on peut déclarer des variables enregistrements exactement de la
même façon que l'on déclare des variables d'un type primitif.
Syntaxe
Variables
nom_var : nom_type
Exemples :
P,P1 : Tpersonne
2.3) Manipulation des enregistrements
La manipulation d'un enregistrement se fait au travers de ses champs. Comme pour les tableaux, il n'est pas
possible de manipuler un enregistrement globalement, sauf pour affecter un enregistrement à un autre de
même type (exemple P P1) . Par exemple, pour afficher un enregistrement il faut afficher tous ses champs
uns par uns.
2.4) L’accès aux champs d’un enregistrement
L’accès aux champs se fait par le nom de la variable suivi d’un point suivi du nom du champ
Exemple :
P.age21
Lire(P.nom)
2.5) Les tableaux d'enregistrement
Il est possible de déclarer un tableau de type enregistrement:
nom_Tab: TABLEAU[taille] DE Type_Structuré;
Dans ce cas, l’accès aux différents champs se fait ainsi:
nom_Tab [indice].NomChamp
Exemple :
TabP : TABLEAU[10] de Tpersonne
TabP[i].nom
2.6) Passage d'un enregistrement en paramètre d'un sous-programme
Il est possible de passer tout un enregistrement en paramètre d'une fonction
Exemple : une fonction qui renvoie la différence d'âge entre deux personnes
Fonction difference (p1, p2 : Tpersonne)
Debut
Si p1.age > p2.age Alors
Retourne ( p1.age – p2.age )
Sinon
Retourne ( p2.age – p1.age )
FinSi
Fin
2.7) L'imbrication des structures
Un type structuré peut être utilisé comme type pour des champs d'un autre type structuré
Exemple :

Centre CPGE TSI - Safi 2010/2011
j. BAKKAS
Type
Structure adresse
num : entier
rue: chaîne
codePostal: entier
ville: chaîne
FinStructure
Structure Tpersonne
nom : chaîne
adr : adresse
âge : entier
FinStructure
Pour accéder à la ville d'une personne, il faut utiliser deux fois l'opérateur « . »
p1.adre.ville
3) Les enregistrements (structures) en C :
3.1) Types, l’instruction typedef
En plus des types de base : int, float, double, char. Le langage C permet de définir de
nouveaux types composés des types de base à l’aide de l'instruction typedef:
Exemples :
Typedef int entier ; // entier est l’equivalent de int
typedef unsigned int uint;
typedef float VecteurT[4]; /*VecteurT represente un type tableau de
quatre réels.*/
Ces nouveaux types peuvent ensuite être utilisés pour déclarer des variables exactement comme les
types primitifs du langage:
Exemples :
entier e ;
uint i;
VecteurT x, y, z;
3.2) Définition
struct nomType{
Type1 nomChamp1
...
Typen nomChampn
} ;
Déclaration
struct nomType nomVariable ;
Exemple :
struct Etudiant{
int num ;
char nom[20] ;
} ;
struct Etudiant
e1,e2 ;
…
Struct Etudiant
e3 ;
…
typedef struct Etudiant
Tetudiant;
Tetudiant e1,e2;
…
Tetudiant e3 ;
…
Il est possible, mais peu recommander de regrouper la définition de la structure et la déclaration des
variables

Centre CPGE TSI - Safi 2010/2011
j. BAKKAS
struct nomType{
Type nomChamp1
...
Type nomChampn
}enreg1,enreg2 ;
Il est possible aussi de définir une structure sans nom de type et déclarer des variables possédants ce type :
struct {
Type nomChamp1
...
Type nomChamp
}enreg ;
En définissant une structure pareille il sera impossible de créer, par la suite, des enregistrements
ayant comme type cette structure.
3.3) Les tableaux d’enregistrements
Déclaration : struct Nom_Structure Nom_Tableau[Nb_Elements];
Exemple :
struct Etudiant classe[28];
1
Alami
2
Eljabri
3
Hamdi
4
Khaldi
… 28
Zaker
B. Allocation dynamique de mémoire en C
1) Adresse mémoire
Une adresse mémoire est l'adresse d'un octet en mémoire centrale (ou du premier octet d'une série
d'octets d'adresses successives). Chaque octet de la mémoire a une adresse unique. Les adresses
permettent aux programmes de se repérer dans la mémoire.
L’espace mémoire occupé par une variable dépend de son type
Adresse Valeur
0 0.321456 double
8 7658 entier
12 23
16 ‘A’ caractère
17 547652
9 123 432 567 1.000028
… …
Pour vérifier la taille de l’espace mémoire occupée par un type ou une variable on utilise
l'opérateur sizeof().
Exemple :
struct Point{
int x;
int y;
};
typedef struct Point point ;
int va ;
printf(“la variable va occupe : %d octets\n“, sizeof(va)) ;
printf(“le type char : %d octets \n“, sizeof(char)) ;
printf("Le type Point : %d octets\n", sizeof(point));

Centre CPGE TSI - Safi 2010/2011
j. BAKKAS
2) Allocation dynamique
2.1) Définition :
L'allocation dynamique de mémoire permet la réservation d'un espace mémoire pour un programme
au moment de son exécution. Contrairement à l'allocation statique de mémoire, où la réservation se
fait dès le début de l'exécution d'un bloc.
3) Allocation dynamique de mémoire en C
Il existe deux principales fonctions C de la bibliothèque <stdlib.h> permettant de demander de la
mémoire au système d'exploitation et de la lui restituer. Elles utilisent toutes les deux les pointeurs,
parce qu'une variable allouée dynamiquement n'a pas d'identificateur, étant donné qu'elle n'est pas
déclarée. Les pointeurs utilisés par ces fonctions C n'ont pas de type. On les référence donc avec des
pointeurs non typés. Leur syntaxe est la suivante :
void *malloc(taille)
free(pointeur)
malloc (abréviation de « Memory ALLOCation »). Elle attend comme paramètre la taille de la
zone de mémoire à allouer et renvoie un pointeur non typé (void *).
free (pour « FREE memory ») libère la mémoire allouée. Elle attend comme paramètre le
pointeur sur la zone à libérer et ne renvoie rien.
Lorsqu'on alloue une variable typée, on doit faire un transtypage du pointeur renvoyé par malloc
en pointeur de ce type de variable.
3.1) Pour réserver un entier
Déclaration d’un pointeur sur un entier :
int *pN ;
pN = (int*)malloc(sizeof(int));
pN pointe maintenant sur une variable (sans nom) de type entier qui a été réservée en mémoire.
Remarque : le (int *) transforme la valeur de retour en pointeur d'entier. On appelle cela un
transtypage (ou casting en anglais).
Manipulation de la variable
*pN = 3; //par exemple
Libération de la mémoire occupée par cette variable :
free(pN);
3.2) Allocation dynamique de tableaux
Déclaration d’un pointeur sur un entier :
int *tab ;
tab = (int*)malloc(3*sizeof(int));
tab pointe vers l'adresse du bloc alloué, c'est à dire le début du tableau. C'est donc un pointeur vers
le premier élément du tableau qui est renvoyé.
Ceci est donc conforme avec le fait qu'un tableau est égal (en terme de pointeur) au premier élément
du tableau. (ie : tab == tab[0] ) . L’accès aux cases du tableau se faire comme suit :
En utilisant les pointeurs En utilisant les indices
*tab= 10;
*(tab + 1) = 15;
*(tab + 2) = 1;
tab[0]=10 ;
tab[1]=15 ;
tab[1]=1 ;