Poly3 ASD

ALGORITHMIQUE
ET STRUCTURES DE DONNEES

Pierre Tellier

17/05/2006

Dpartement d'Informatique de l'Universit Louis Pasteur,

7 rue Ren Descartes, F67084 STRASBOURG CEDEX,
e-mail : tellier@dpt-info.u-strasbg.fr, Tel : +33 (0) 3 90 240 300

Algorithmique et Structures de Donnes Page 2 Pierre Tellier

Table des matires

Table des matires ............................................................................................................................................ 2
Structures de donnes....................................................................................................................................... 4
Structures simples......................................................................................................................................... 4
Structures imbriques ................................................................................................................................... 5
Exemple : fiche de renseignement ........................................................................................................... 5
Bonne utilisation des structures................................................................................................................ 6
Structures rcursives et croises.............................................................................................................. 8
Tableaux multidimensionnels ............................................................................................................................ 9
Les tableaux statiques 2 dimensions ......................................................................................................... 9
Matrices..................................................................................................................................................... 9
Matrices dynamiques .................................................................................................................................. 12
Tableaux mono-dimensionnels............................................................................................................... 12
Tableaux de tableaux.............................................................................................................................. 13
Quelques reprsentations de molcules ................................................................................................ 14
Tableaux de dimension suprieure 2....................................................................................................... 14
Tris de tableaux ............................................................................................................................................... 15
Tables .............................................................................................................................................................. 17
Dfinition...................................................................................................................................................... 17
Reprsentation des tables........................................................................................................................... 17
fonction daccs ...................................................................................................................................... 17
Modes dadressage................................................................................................................................. 17
Partage de tables.................................................................................................................................... 18
Le rangement dispers................................................................................................................................ 19
Les fonctions de hachage....................................................................................................................... 19
Les fonctions de hachage....................................................................................................................... 20
Complment : rsolution des conflits de tables de hachages ................................................................ 20
Fichiers et entres/sorties ............................................................................................................................... 21
Fichiers physiques, fichiers logiques........................................................................................................... 21
Assignation.............................................................................................................................................. 21
Ouverture ................................................................................................................................................ 21
Entres/Sorties formates........................................................................................................................... 22
Lecture .................................................................................................................................................... 22
Ecriture.................................................................................................................................................... 23
Lecture et criture formates en C......................................................................................................... 23
Fermeture d'un fichier ............................................................................................................................. 23
Fichiers binaires .......................................................................................................................................... 23
Lecture et criture binaires en C............................................................................................................. 23
Application : sauvegarde d'un tableau.................................................................................................... 24
Introduction la cinmatique des fichiers................................................................................................... 24
Les listes chanes .......................................................................................................................................... 25
Gnralits .................................................................................................................................................. 25
Le type liste ................................................................................................................................................. 25
Oprations lmentaires sur les listes ........................................................................................................ 26
Dclaration et initialisation ...................................................................................................................... 26
Test de vacuit........................................................................................................................................ 26
Accs la premire information de la liste : la tte ................................................................................ 26
Accs la deuxime composante : la queue ......................................................................................... 26
Ajout d'un lment en tte ...................................................................................................................... 27
Suppression de l'lment en tte............................................................................................................ 27
Autres oprations utiles sur les listes : notion de type abstrait ................................................................... 28
Longueur d'une liste................................................................................................................................ 28
Ajout en queue........................................................................................................................................ 28
Suppression du dernier lment ............................................................................................................. 28
Insertion en une position donne............................................................................................................ 29
Suppression d'un lment de position donne....................................................................................... 30
Insertion trie (ou sur critre quelconque) .............................................................................................. 30
Exemple d'utilisation ............................................................................................................................... 30
Structures rcursives et croises................................................................................................................ 32

Chanages multiples.................................................................................................................................... 32
Les piles........................................................................................................................................................... 33
Modlisation de la structure ........................................................................................................................ 33
Introduction ............................................................................................................................................. 33
Modlisation par liste chane ................................................................................................................ 33
Modlisation par tableau......................................................................................................................... 33
Oprations sur la structure.......................................................................................................................... 33
Introduction ............................................................................................................................................. 33
Oprations pour la modlisation par liste chane.................................................................................. 34
Oprations pour la modlisation par tableau.......................................................................................... 35
Conclusion................................................................................................................................................... 36
Les files............................................................................................................................................................ 37
Modlisation de la structures....................................................................................................................... 37
Introduction ............................................................................................................................................. 37
Modlisation par liste chane ................................................................................................................ 37
Modlisation par tableau circulaire ......................................................................................................... 37
Oprations sur la structure.......................................................................................................................... 38
Introduction ............................................................................................................................................. 38
Oprations pour la modlisation par liste chane.................................................................................. 38
Oprations pour la modlisation par tableau circulaire .......................................................................... 39
Conclusion................................................................................................................................................... 40
Les arbres........................................................................................................................................................ 41
Gnralits .................................................................................................................................................. 41
Le type Arbre Binaire................................................................................................................................... 41
Oprations de base................................................................................................................................. 41
Arbres binaires ordonns........................................................................................................................ 44
Application : les arbres dictionnaires ...................................................................................................... 45
Parcours heuristique darbres ..................................................................................................................... 47
Exemple : le jeu du taquin....................................................................................................................... 47
Arbres quilibrs (bien balancs)................................................................................................................ 48
Arbres n-aires.............................................................................................................................................. 49
Modlisation des arbres n-aires.............................................................................................................. 49
Les graphes..................................................................................................................................................... 50
Dfinition...................................................................................................................................................... 50
Parcours des graphes ................................................................................................................................. 51
Reprsentation des graphes ....................................................................................................................... 52
Fonctions de manipulation des graphes................................................................................................. 54
Application : graphe de reprsentation d'une molcule .............................................................................. 55
Plus courts chemins ( origine unique) ....................................................................................................... 55
Algorithme de Dijkstra............................................................................................................................. 55
Algorithme de Bellman-Ford ................................................................................................................... 56


Structures de donnes
De nombreux objets traits par les programmes ne peuvent pas tre reprsents l'aide d'un seul nombre
ou d'une chane, mais sont constitus naturellement de plusieurs informations :
une date = un jour, un mois, une anne ;
un nombre complexe = une partie relle, une partie imaginaire ;
un tableau = l'adresse de son premier lment, sa taille physique et sa taille effective ;
une sphre = un centre, un rayon ;
une personne = un nom, un prnom ;
une adresse = un numro, une rue, une ville, un code postal;
...
Une information lmentaire dans un objet est appele un champ. Pour accder l'information contenue
dans un champ d'un objet composite, il suffit d'ajouter un point au nom de l'objet et de le faire suivre du nom
du champ.
Structures simples
Voici un exemple de dfinition et dutilisation de structures. Il porte sur les dates, constitues de 3
informations : nom de jour (dans la semaine), jour dans le mois, mois et anne.
typedef struct { /* ou typedef struct T_Date */
int jour, mois, annee;
char lejour[9]; /* "lundi", ...., "dimanche" */
} Date;

Date d1, d2;
d1.jour = 24;
d1.mois = 12;
d1.annee = 1965;
d2.annee = d1.annee+3;
printf("%d-%d-%d\n",d1.jour,d1.mois,d1.annee);}
Nous donnons deux versions de fonction de calcul de la veille d'une date. La premire dlivre un rsultat
Date (version recommande, car sans pointeur), la deuxime modifie la date passe en paramtre ( viter).
Date veille(Date d)
{
Date res = d;
if (res.jour != 1) res.jour--;
else if (res.mois != 1) {
res.mois--;
res.jour = nbJoursDansMois(res.mois,res.annee);
}
else {
res.jour = 31;
res.mois = 12;
res.annee--;
}
return res;
}

void veille(Date *d)
{
if ((*d).jour != 1) (*d).jour--;
else if ((*d).mois != 1) {
(*d).mois--;
(*d).jour = nbJoursDansMois((*d).mois,(*d).annee);
}
else {
(*d).jour = 31;
(*d).mois = 12;
(*d).annee--;
}
}

Remarque : (*d).jour est identique d->jour. C'est d'ailleurs la notation que l'on rencontre le plus
souvent. En revanche, l'criture *f.adresse est quivalente *(f.adresse).
Structures imbriques
Exemple : fiche de renseignement
Nous dfinissons un type FICHE, destin contenir des informations sur des personnes. Ces informations
sont : nom, prnom, adresse, date de naissance, sachant qu'une adresse est constitue d'un numro, d'un
nom de rue, d'un code postal et d'une ville, alors que la date de naissance est la runion de 3 informations :
jour, mois et anne. Nous dfinissons notre type ainsi :
#include <stdio.h>
#include <string.h>
typedef struct t_date {
int j, m;
char a[3]; /* annee = 2 caractres + fin de chane = bug an 2000 :) */
} TDate;

typedef struct t_adresse {
int numero, code;
char *rue, *ville;
} TAdresse;

typedef struct t_fiche {
char *nom, *prenom; /* pointeurs sur nom et prenom */
TDate naissance; /* date de naissance */
TAdresse *adresse; /* pointeurs sur adresse => pas prsente */
} TFiche;
Nous crivons ensuite les fonctions permettant d'initialiser une fiche. Pour rduire le risque d'erreurs, il est
impratif de procder comme dans l'exemple, c'est--dire de ne pas tenter d'accder directement aux sous-
champs des champs, mais de passer par des objets intermdiaires qui n'ont qu'un seul niveau de
dcomposition et qui sont plus simples initialiser. Certaines fonctions fonctionnent sur le mode des
paramtres modifiables, ce qu'il vaut mieux viter en principe.
void saisieAdresse(TAdresse *adr)
{
char chaine[1024];
int n;

printf("Saisie de l'adresse\n");
printf("Numero : "); scanf("%d", &n);
adr->numero = n;
printf("Nom de la rue : "); scanf("%s", chaine);
adr->rue = strdup(chaine);
printf("Code Postal : ");scanf("%d",&adr->code); /* ou adr.code (rare) */
printf("Ville : "); scanf("%s", chaine);
adr->ville = strdup(chaine);

return ;
}

TDate saisieNaissance(void)
{
TDate d;

printf("Saisie de la date de naissance\n");
printf("Jour : "); scanf("%d", &d.j);
printf("Mois (1-12) : "); scanf("%d", &d.m);

printf("Anne (19XX) : "); scanf("%s", d.a);

return d;
}


void saisieFiche(TFiche *f)
{
char chaine[1024];
TAdresse *adr;
TDate date;

printf("Nom : "); scanf("%s", chaine);
f->nom = strdup(chaine);
printf("Prnom : "); scanf("%s", chaine);
f->prenom = strdup(chaine);

adr=(Tadresse*)malloc(sizeof(TAdresse)); /*allouer une nouvelle adresse*/
/* il ne faudra pas la librer */
f->adresse = adr; /* le champ adresse pointe sur la nouvelle adresse */
saisieAdresse(adr);
/* plus facile que : scanf("%d", &f->adresse->numero); !!! */

date = saisieNaissance();
f->naissance = date; /* recopie de la date f->naissance=saisieDate(); */
/* plus facile que : scanf("%d", &f->naissance.j); !!! */
}
Nous donnons enfin un exemple d'utilisation de ces fonctions : une fonction qui permet de visualiser le
contenu de la structure, et un programme principal qui manipule ces fonctions.
void visuAdresse(TAdresse adr)
{
printf("%d rue %s, %d %s\n", adr.numero, adr.rue, adr.code, adr.ville);
}

void visuDate(TDate d)
{
printf("%d %d 19%s\n", d.j, f.naissance.m, f.naissance.a);
}

void visuFiche(TFiche f)
{
TAdresse *adr;
TDate d;

adr = f.adresse;
d = f.naissance;
printf("%s %s\n", f.nom, f.prenom);
printf("Adresse : "); visuAdresse(*adr);
printf("N(e) le : "); visuDate(d);
}

int main(int argc, char **argv)
{
TFiche fiche;

saisieFiche(&fiche);
visuFiche(fiche);
exit(0);
}

Bonne utilisation des structures
Dans la mesure du possible, on vitera de crer des fonctions qui passent des structures par adresse, car
l'criture de ces fonctions est complexe et conduit de frquentes erreurs. Pourtant il est ncessaire de
connatre cette possibilit vue prcdemment, car elle est un peu plus rapide l'excution, et de
nombreuses fonctions, en particulier systme, que l'on peut tre amen utiliser sont crites sous cette
forme.
Une autre amlioration possible consiste na pas faire directement rfrence aux noms des champs, mais
utiliser des fonctions d'accs. L'avantage est qu'en cas de modification de la structure ou des identificateurs

des champs, seule la fonction d'accs doit tre mise jour. Voici l'exemple prcdent r-crit en tenant
compte de ces 2 remarques. On continue bien sur ne pas utiliser plus d'un niveau de structures la fois.

TAdresse setAdrNum(Tadresse adr, int n)
{
Tadresse adr2=adr;
adr2.numero = n;
return adr2;
}

TAdresse setAdrRue(Tadresse adr, char *ch)
{
Tadresse adr2=adr;
if (adr2.rue != NULL) free(adr2.rue);
adr2.rue = strdup(ch);
return adr2;
}

TAdresse setAdrCode(Tadresse adr, int c)
{
Tadresse adr2=adr;
adr2.code = c;
return adr2;
}

TAdresse setAdrVille(Tadresse adr, char *ch)
{
Tadresse adr2=adr;
if (adr2.ville != NULL) free(adr2.ville);
adr2.ville = strdup(ch);
return adr2;
}

TAdresse saisieAdresse(void)
{
char chaine[1024];
int n, c;
TAdresse adr;

printf("Saisie de l'adresse\n");
printf("Numero : "); scanf("%d", &n);
adr = setAdrNum(adr, n);
printf("Nom de la rue : "); scanf("%s", chaine);
adr = setAdrRue(adr, chaine);
printf("Code Postal : "); scanf("%d",&c);
adr = setAdrCode(adr, c);
printf("Ville : "); scanf("%s", chaine);
adr = setAdrVille(adr, chaine);

return adr;
}

int getAdrNum(Tadresse adr)
{
return adr.numero;
}

char * getAdrRue(Tadresse adr)
{
return adr.rue;
}


int getAdrCode(Tadresse adr)
{
return adr.code;
}

char * getAdrVille(Tadresse adr)
{
return adr.ville;
}

void visuAdresse(TAdresse adr)
{
printf("%d rue %s, %d %s\n", getAdrNum(adr), getAdrRue(adr),
getAdrCode(adr), getAdrVille(adr));
}

Structures rcursives et croises


Tableaux multidimensionnels

Les tableaux statiques 2 dimensions
Ils sont utiliss pour reprsenter des matrices, ou toutes autres formes de donnes rectangulaires (images,
feuilles de calcul de tableur, modles numriques de terrain, etc...). C'est aussi de cette faon que sont
organises certains rsultats dinterrogation de bases de donnes : un tableau d'enregistrements, chaque
enregistrement tant un tableau de champs, mme si ici les champs n'ont pas tous le mme type (texte,
valeur etc.).
Matrices
Prenons l'exemple des matrices. En mathmatique, on dsigne chaque lment d'une matrice par a
ij
o i est
le numro de ligne et j celui de colonne. En programmation, il en va de mme : si m est une matrice de taille
M lignes et N colonnes, on la dclare l'aide d'un tableau par :
float m[M][N];
Comme pour les tableaux mono-dimensionnels, la numrotation commence 0 pour les lignes et pour les
colonnes, donc l'lment a
ij
est obtenu par m[i-1][j-1], ou rciproquement, l'lment m[i][j] d'un
tableau est celui situ la (i+1)me ligne et (j+1)me colonne. Pour illustrer nos propos, nous prenons le
cas des matrices carres 3x3, pour lesquels nous dfinissons un nouveau type, le type Matrice3x3.
typedef float Matrice3x3[3][3];

Matrice3x3 m1,m2;
Matrice3x3 identite= { {1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 0.0, 1.0}};
En mmoire, tous les lments d'un tableau 2 dimensions sont contigus : d'abord ceux de la premire
ligne, puis ceux de la deuxime etc. Les tableaux 2D sont donc des tableaux de tableaux. L'adresse de
l'lment m[i][j] est celle du premier + (i*Nombre de colonnes) + j. Donc on peut trs facilement
programmer des matrices avec des tableaux une dimension.
Matrice3x3 m;
float t[3*3];
t[i*3+j]=m[i][j];
Tout d'abord, voyons une fonction permettant de fixer les valeurs de chaque lment d'une matrice. Pour
accder tous les lments, on imbrique deux boucles :
pour toutes les lignes faire
pour tous les lments sur chaque colonne de la ligne courante faire
traitement de l'lment (ligne courante, colonne courante)
finpour
finpour
Dans les exemples suivants, on utilise l'indice i pour dsigner les lignes, et j pour les colonnes.
void initMatrice(Matrice3x3 m)
{
int i,j;

for(i=0;i<3;i++)
for(j=0;j<3;j++) {
printf("entrez l'lment m[%d][%d] : ",i,j);
scanf("%d", &m[i][j]);
}
}
De la mme manire, la fonction qui affiche l'cran une matrice 3x3 est :
void afficheMatrice(Matrice3x3 m)
{
int i,j;

for(i=0;i<3;i++) {
for(j=0;j<3;j++)

printf("%6.2f ",m[i][j]);
printf("\n");
}
}
La matrice identit est celle dont les lments de la diagonale (mme numro de ligne et de colonne) valent
1, alors que tous les autres valent 0.
void initIdentite(Matrice3x3 m)
{
int i,j;

for(i=0;i<3;i++)
for(j=0;j<3;j++)
m[i][j]=(float)(i==j);
}
La recopie d'une matrice dans une autre est quasiment identique la recopie d'un tableau dans un autre. On
peut la pratiquer lment par lment, ligne par ligne ou d'un seul coup.
void copieMatrice(Matrice3x3 m, Matrice3x3 m2)
{
int i,j;

for(i=0;i<3;i++)
for(j=0;j<3;j++)
m2[i][j]=m[i][j];
}

{
int i;

for(i=0;i<3;i++)
recopieTableauFloat(m[i], 3, m2[i], 3);
// ou memcpy(m2[i], m[i], 3*sizeof(float));
}

{
memcpy(m2, m, sizeof(Matrice3x3));
}
La somme de 2 matrices A et B est une matrice C o chaque lment c
ij
est la somme des lments
correspondants a
ij
et b
ij

void sommeMatrices(Matrice3x3 A, Matrice3x3 B, Matrice3x3 C)
{
int i,j;

for(i=0;i<3;i++)
for(j=0;j<3;j++)
C[i][j]=A[i][j]+B[i][j];
}
La transpose A
t
d'une matrice A est obtenue en inversant simplement numros de ligne et numros de
colonne. Dites ce qui peut poser problme dans la premire version, et comparez avec la deuxime.
void transposeMatrice(Matrice3x3 A, Matrice3x3 At)
{
int i,j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
At[i][j]=A[j][i];
}

void transposeMatrice(Matrice3x3 A, Matrice3x3 At)
{
int i,j;
for(i=0;i<3;i++)

for(j=0;j<3;j++)
At[i][j]=A[i][j];
for(i=0;i<3;i++)
for(j=0;j<i;j++)
permuterEntiers(&At[i][j], &At[j][i]);
}

La matrice C rsultant du produit de 2 matrices A et B (le nombre de colonnes de A doit tre gal au nombre
de lignes de B, on le note n) est obtenu par la formule :
=
=
n
k
kj ik ij
b a c
0
. Notez que l'on passe par une
matrice intermdiaire sinon la fonction rend des rsultats errons lorsqu'on l'utilise avec accumulation :
produitMatrices(A, B, A) ou produitMatrices(A, B, B) .
void produitMatrices(Matrice3x3 A, Matrice3x3 B, Matrice3x3 C)
{
Matrice3x3 Ctmp;
int i,j,k;

for(i=0;i<3;i++)
for(j=0;j<3;j++)
{
Ctmp[i][j]=0.0;
for (k=0;k<3;k++)
Ctmp[i][j] += A[i][k]*B[k][j];
}
copieMatrice(Ctmp,C);
}
Enfin un exemple d'utilisation de ces fonctions sur les matrices :
main()
{
Matrice3x3 A,B,C;

initMatrice(A);
initMatrice(B);
produitMatrice(A,B,C);
afficheMatrice(C);
}
Et encore quelques fonctions utiles, comme l'application d'une matrice une vecteur :
/* Application d'une matrice un vecteur */
void appliqueMatrices(Matrice3x3 m, vecteur v1, vecteur v2)
{
int i,k;
vecteur v2t;

for(i=0;i<3;i++)
{
v2t[i]=0.0;
for (k=0;k<3;k++)
v2t[i] += m1[i][k]*v1[k];
}
recopieTableauFloat(v2t, 3, v2, 3);
}
ou l'inversion d'une matrice 3x3 avec calcul du dterminant :
/* Inversion de matrice 3x3. Rsultat : succs ou chec */
int inverseMatrice(Matrice3x3 m, Matrice3x3 m2)
{
float determinant, unSurDeterminant;
float cf[3][3];
int i, j, res=0;

determinant = m[0][0]*(m[1][1]*m[2][2] - m[1][2]*m[2][1]) -
m[0][1]*(m[1][0]*m[2][2] - m[1][2]*m[2][0]) +

m[0][2]*(m[1][0]*m[2][1] - m[1][1]*m[2][0]);
if (determinant != 0.0) {
res = 1;
unSurDeterminant = 1.0 / determinant;
cf[0][0] = m[1][1]*m[2][2] - m[1][2]*m[2][1];
cf[0][1] = -(m[1][0]*m[2][2] - m[1][2]*m[2][0]);
cf[0][2] = m[1][0]*m[2][1] - m[1][1]*m[2][0];

cf[1][0] = -(m[0][1]*m[2][2] - m[0][2]*m[2][1]);
cf[1][1] = m[0][0]*m[2][2] - m[0][2]*m[2][0];
cf[1][2] = -(m[0][0]*m[2][1] - m[0][1]*m[2][0]);

cf[2][0] = m[0][1]*m[1][2] - m[0][2]*m[1][1];
cf[2][1] = -(m[0][0]*m[1][2] - m[0][2]*m[1][0]);
cf[2][2] = m[0][0]*m[1][1] - m[0][1]*m[1][0];

for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
m2[i][j] = unSurDeterminant*cf[j][i];
}
return res;
}
Matrices dynamiques
Aprs ces exemples sur les matrices de taille 3x3, nous montrons comment manipuler des informations
bidimensionnelles de taille quelconque.
Tableaux mono-dimensionnels
La manire la plus pratique de reprsenter notre tableau 2 dimensions de tailles inconnues l'avance est
incontestablement l'utilisation d'un tableau allou dynamiquement. Le principal inconvnient est que l'accs
l'lment sur la i-me ligne et la j-me colonne d'une matrice M de L lignes de chacune C colonnes devient
un peu moins intuitif : M[i*C+j] au lieu de M[i][j] pour un vritable tableau bidimensionnel. Il devient
bien sr ncessaire de prciser, en paramtres des fonctions de manipulation de tels tableaux, leurs
dimensions. Par exemple voici la fonction qui calcule (si possible) le produit de 2 matrices rcrite selon ces
conventions. Chaque matrice est un pointeur sur des nombres rels, complte par son nombre de lignes
nl et nombre de colonnes nc. On suppose la matrice rsultat est pralablement alloue, c'est pourquoi on
fournit aussi sa taille physique totale en paramtre. Cette version n'est pas optimale, puisqu'on pourrait faire
un calcul incrmental des indices, qui viterait toutes ces multiplications chaque itration. Toutefois, pour
rester peu prs lisible, nous ne prsentons pas de version plus optimise, ce qui est dailleurs inutile car
aujourd'hui les compilateurs sont capables de pratiquer eux-mmes ces amliorations.
/* calcul du produit m3 = m1 * m2, *nl3, *nc3 : taille de la matrice produit */
int produitMatrices(float *m1, int nl1, int nc1, float *m2, int nl2, int nc2,
float *m3, int taille, int *nl3, int *nc3)
{
float *m3t=NULL;
int res=0,i,j,k;
if ((nc1 == nl2) && (nl1*nc2 <= taille)) {
res=1; *nl3=nl1; *nc3=nc2;
CALLOC(m3t, float, nl1*nc2);
for(i=0;i<nl1;i++)
for(j=0;j<nc2;j++) {
m3t[i*n1+j]=0.0;
for (k=0;k<nc1;k++)
m3t[i*nc2+j] += m1[i*nc1+k]*m2[k*nc2+j];
}
memcpy((void *)m3, (void *)m3t, nl1*nc2*sizeof(float));
FREE(m3t);
}
return res;
}

Tableaux de tableaux
Cette approche est un peu plus lourde que l'approche prcdente, nanmoins elle prsente 2 avantages : on
conserve la notation intuitive d'accs aux donnes en laissant le soin au compilateur de calculer lui-mme
l'adresse de chaque lment. Du fait que chaque ligne est reprsente par un tableau dynamique, cette
mthode est bien adapte aux cas o les lignes n'ont pas la mme longueur. Cela est assez rare, mais se
produit par exemple pour les tables 2 entres qui sont symtriques, comme un tableau de distance entre
villes, pour lequel on n'a pas besoin d'un rectangle puisqu'un triangle suffit. Nous reprenons l'exemple
prcdent qui consiste raliser le produit de 2 matrices. Les matrices seront reprsentes l'aide d'un
tableau dynamique de tableaux dynamiques. En langage C, cela s'exprime par un double pointeur ou
pointeur de pointeur :
typedef float **Matrice;
Notre fonction de multiplication de matrice est intressante, car elle procde l'allocation d'une matrice
temporaire. Dans cette version, nous avons suppos que la matrice m3 est dj correctement alloue en
dehors de la fonction, et avec les bonnes dimensions.
int produitMatrices(Matrice m1, int nl1, int nc1, Matrice m2, int nl2, int nc2,
Matrice m3)
{
Matrice m3t=NULL;
int res=0,i,j,k;

if (nc1 == nl2) {
res=1;
CALLOC(*m3t, float *, nl1); /* allocation du tableau de lignes */
for(i=0;i<nl1;i++) {
CALLOC(m3t[i], float, nc2); /* allocation des lignes */
m3t[i][j]=0.0;
for (k=0;k<nc1;k++)
m3t[i][j] += m1[i][k]*m2[k][j];
}
}
memcpy((void *)m3[i], (void *)m3t[i], nl1*nc2*sizeof(float));
FREE(m3t[i]);
}
FREE(m3t);
}

return res;
}
Pour amliorer la lisibilit, nous conseillons vivement d'crire les fonctions d'allocation et de ds-allocation
de ce type de matrice :
Matrice alloueMatrice(int nl, int nc)
{
int i;

Matrice m=NULL;
CALLOC(m, float *, nl); /* allocation du tableau de lignes */
for(i=0;i<nl1;i++) CALLOC(m[i], float, nc); /* allocation des lignes */

return m;
}

Matrice desAlloueMatrice(Matrice m, int nl, int nc)
{
int i;
for(i=0;i<nl;i++) FREE(m[i]);
FREE(m);
return m;
}
Ce qui donne finalement la fonction de multiplication de matrices :


int produitMatrices(Matrice m1, int nl1, int nc1,Matrice m2, int nl2, int nc2,
Matrice m3)
{
Matrice m3t=NULL;
int res=0,i,j,k;

if (nc1 == nl2) {
res=1;
m3t = alloueMatrice(nl1, nc2);
m3t[i][j]=0.0;
for (k=0;k<nc1;k++)
m3t[i][j] += m1[i][k]*m2[k][j];
}
}
for(i=0;i<nl1;i++)
memcpy((void *)m3[i], (void *)m3t[i], nl1*nc2*sizeof(float));
m = desAlloueMatrice(m, nl1, nc2);
}
return res;
}

Quelques reprsentations de molcules
Prenons par exemple la molcule CH
3
OH, dont les liaisons entre atomes sont illustres par la figure qui suit :

Voici quelques faons de reprsenter cette information :
Atomes et couples datomes (+ valence)
(C, H, H, H, O, H) + ( (1,2), (1,3), (1,4), (1,5), (5,6) )
Atomes et tableau de liaisons
(C, H, H, H, O, H) +

Atomes et listes de voisins
- (C, H, H, H, O, H) + (1,(2,3,4,5)), (2,(1)), (3,(1)), (4,(1)), (5,(1,6)), (6,(5))
- (C, H, H, H, O, H) + ( (2,3,4,5), (1), (1), (1), (1,6), (5) )
Graphe avec pointeurs
SMILE

Tableaux de dimension suprieure 2
C(1) H(2) H(3) H(4) 0(5) H(6)
x x x x C(1)
x H(2)
x H(3)
x H(4)
x x O(5)
x H(6)
C(1) H(2) H(3) H(4) 0(5) H(6)
x x x x C(1)
H(2)
H(3)
H(4)
x O(5)
H(6)

Tris de tableaux

Tri fusion
Le cot du tri naf (et de ses variantes) tant de l'ordre de n
2
, le tri d'un demi tableau sera de l'ordre de (n/2)
2
,
soit n
2
/4. Le cot du tri des 2 sous-tableaux sera alors de n
2
/2. Si on applique la mme stratgie pour trier
les deux sous-tableaux, on obtient un tri donc le cot devient alors de l'ordre de n.log n.

Il ne reste plus qu' mettre en place les fonctions qui effectuent la sparation du tableau en sous-tableaux, et
qui fusionnent les 2 sous-tableaux tris en un nouveau tableau tri. Un tableau vide ou contenant un seul
lment est considr comme dj tri. Ce tri par fusion peut tre ralis sans utiliser les tableaux
intermdiaires tab1 et tab2.
void separe(int tab[], int n, int tab1[], int *n1, int tab2[], int *n2)
{
int i,j=0;
*n1= n/2; *n2=n-*n1;
for(i=0; i<*n1; i++) tab1[i]=tab[i];
for(i=*n1; i<n; i++) tab2[j++]=tab[i];
}

void fusion(int tab1[], int n1, int tab2[], int n2, int tab[])
{
int i,j=0,k=0;
for(i=0; i<n1+n2; i++)
if (j >= n1) tab[i] = tab2[k++];
else if (k >= n2) tab[i] = tab1[j++];
else if (tab1[j] < tab2[k]) tab[i] = tab1[j++];
else tab[i] = tab2[k++];
}

void triFusion(int tab[], int n)
{
int tab1[MAXTAILLE], tab2[MAXTAILLE], n1, n2;

if (n > 1) {
separe(tab, n, tab1, &n1, tab2, &n2);
triFusion(tab1, n1);
triFusion(tab2, n2);
fusion(tab1, n1, tab2, n2, tab);
}
}

Tri rapide
Le principe de la mthode prcdente est trs intressant, puisqu'il permet de rduire de manire
significative le nombre d'oprations effectuer. Nanmoins, le cot des fonctions de sparation et de fusion
est encore trop important. En particulier la fusion exige la comparaison des premiers lments de chaque
sous-tableau tri. La mthode dite du tri rapide remdie cela par sa faon de diviser le tableau tout fait
originale : partir d'un tableau, et d'une valeur appele pivot, elle coupe en deux parties le tableau de telle
sorte que tous les lments de la premire partie soient infrieurs (ou gaux) au pivot et ceux de la
deuxime partie soient suprieurs. De cette manire, la fusion sera grandement simplifie puisqu'il suffira de
mettre bout bout les 2 sous-tableaux. La difficult consiste choisir un pivot, qui donne deux sous
tableaux dont les tailles sont le plus proche possible, et mettre en uvre le plus efficacement possible la
sparation. Cela sera fait de telle sorte que le tri est fait directement dans le tableau, sans tableaux
intermdiaires. Des analyses statistiques ont montr que dans la plupart des cas, on peut prendre comme
pivot la mdiane de 3 valeurs du tableau prises au hasard. Une fois ce pivot trouv, on parcourt le tableau
en partant de ses 2 extrmits, et dans chaque sens, on s'arrte quand on trouve une valeur qui n'est pas
dans la bonne partition. Lorsqu'on a deux lments la mauvaise place, on les permute. On rpte ce calcul
jusqu' ce qu'on se croise.
int lePivot(int tab[], int i, int j)
{
int v[3];
v[0] = tab[i+rand()%(j-i+1)];
v[1] = tab[i+rand()%(j-i+1)];
v[2] = tab[i+rand()%(j-i+1)];
triBulle(v,3); // ou un autre tri
return v[1];
}
int separe(int tab[], int pivot, int deb, int fin)
{
int i=deb, j=fin, finBoucle=(deb>=fin);
while(!finBoucle) {
while(tab[i]<=pivot) i++;
while(tab[j]>=pivot) j--;
if (i>=j) finBoucle=1;
else permuterEntiers(&tab[i], &tab[j]);
}
return j;
}
void triRapide(int tab[], int deb, int fin)
{
int pivot, ppivot;
if (fin > deb) {
pivot = lePivot(tab, deb, fin);
ppivot = separe(tab, pivot, deb, fin);
triRapide(tab, deb, ppivot);
triRapide(tab, ppivot+1, fin);
}
}
En langage C il existe une fonction de tri optimise de tri avec pivot. Elle porte le nom de qsort et on
l'utilise ainsi : il faut disposer d'une fonction de comparaison de 2 lments a et b retournant une valeur
ngative si a doit tre avant b, positive dans le cas contraire. Cette fonction prend en paramtres les
pointeurs sur ces 2 lments. Comme la fonction qsort est gnrique (prvue pour fonctionner sur
n'importe quel type de donnes), il est ncessaire de se conformer au type void = n'importe quel type. Voici
comment l'employer pour trier un tableau d'entiers :
int compare(int *a, int *b)
{
return *a-*b;
}
int tri(int *tab, int n)
{
qsort((void *)tab,n,sizeof(int),(int(*)(const void *,const void *))compare);
}


Tables
Ce chapitre est reproduit du cours dAlgorithmique Avanc, par Jean-Michel DISCHLER, dischler@dpt-
info.u-strasbg.fr, avec son aimable autorisation.
Dfinition
Une table t est une fonction partielle de E dans S, o E est un type dentres (aussi dit index, indice ou cl)
et S un type de valeurs.
Exemple : une table t : chane chane fait correspondre un nom de dpartement le code postal. Par
exemple, pour le Bas-Rhin le code 67.
Les oprations usuelles sur les tables sont :
ADJONCTION(t, e, s) t : adjonction dun lment la table, de cl e et de valeur s ;
SUPPRESSION(t, e) t : suppression de llment de cl e ;
ELEMENT(t, e) s : accs la valeur de llment de cl e ;

Reprsentation des tables
Il est important de ne pas confondre table et tableau. Un tableau est un cas particulier de la table avec
comme entre (index ou cl) un entier et comme type de valeur, le type du tableau. Evidemment, le tableau
peut servir de moyen de modliser des tables, mais ce nest pas la seule approche. Par exemple, dans
certains cas une table peut tre reprsente par une fonction. La table qui associe aux n premiers entiers
leur carr, est directement donne sous la forme dune fonction mathmatique du calcul de carr.
Pour modliser des tables, on passe souvent par un ensemble dadresses intermdiaires :
E AS
i a(i) f(a(i))=t(i)
On appelle a() la fonction dadressage et f () la fonction daccs la valeur recherche.
fonction daccs
Accs direct
Dans ce cas f donne le contenu dune cellule dont on connat ladresse. Pour une entre i, a(i) donne lindice
de la case du tableau contenant t(i) = f (a(i)).
Exemple : La table du nombre des jours dans le mois. On utilise un tableau v[12]. Avec a(i) = i-1, on obtient
t(i) = v[i-1].
Accs indirect
Ici la fonction f peut tre vue comme donnant le contenu du contenu dune cellule dont on connat ladresse.
On peut utiliser un tableau ta pour ranger les adresses des valeurs de la table t. Celles-ci peuvent tre
mmorises dans un autre tableau v.

Table des noms de dpartement.

Exemple : Soit t la table des noms de dpartement partir de leurs numros, allant de 1 95. a(i) = i-1.
Dans le schma ci-dessus, on voit que ta donne lindice du caractre dans le tableau v des chanes. Cet
exemple est utile dans le cas o le tableau est statique, car les modifications ne sont pas trs aises.
Modes dadressage
Adressage calcul
Le principe consiste calculer a(i) laide dune fonction injective (cest une fonction telle que a(i) = a(j)
implique i =j). Ctait dj le cas dans les exemples prcdents.
Exemple : En langage ADA, un tableau plusieurs dimensions se dclare de la manire suivante : t : array
(a1..b1,a2..b2, ... , ap..bp) of TYPE. Un tableau de ce type peut tre vu comme une table associant des p-
uplets une valeur de TYPE. Cette table peut elle mme tre implmente sous forme de tableau v dont les
lments sont indics de 0 n-1, avec n = (b1-a1+1)(b2-a2+1)...(bp-ap+1).

Il faut passer dun p-uplet dindices i=(i1, i2, ..., ip). lindice ap(i) correspondant dans v. Le calcul se fait par
relation de rcurrence : ap(i) = (bp-ap+1)ap-1(i1, ..., ip-1)+ip-ap. En dveloppant cette formule, on obtient une
combinaison linaire des ik -ak.
Adressage associatif
Dans un adressage associatif, on reprsente uniquement les entres effectives par une liste dont les
adresses sont associes.
Exemple : Soit une table t qui associe un nom de dpartement le nom du chef-lieu.

Table des chef-lieux par dpartement.

a(i) est lindice de la case contenant i. La valeur de t(i) est obtenue par un tableau associ v[a(i)]. Dans ce
cas, a(i) est obtenu par recherche dichotomique (les dpartements sont tris par ordre alphabtique). La
fonction daccs est directe. Le problme gnral de ce type de reprsentation est que les oprations
dadjonctions ou suppressions sont lourdes. Il est intressant pour ces traitements dutiliser une
reprsentation mixte, contigu et chane.

Table des chef-lieux par dpartement, avec une structure mixte contigu et chane.

Dans lexemple prcdent, on utilise deux tableaux de structures pour raliser la table. Le premier tableau
contient les lments de manire contigu et trie. Dans le second les lments sont chans. Le chanage
est ralis par le biais dindices. Le second tableau peut tre considr comme une zone de dbordement.
La seule difficult avec ce type de reprsentation est la gestion dun nombre ventuellement important de
dbordements. En pratique, quand on saperoit que lon utilise beaucoup dlments en dbordement, il
faut rorganiser les listes en dplaant des lments du second tableau vers le premier tableau.
Partage de tables
Il est parfois plus efficace de partager (partitionner) les entres en sous-ensembles, cest--dire davoir des
sous-tables plusieurs niveaux. A deux niveaux, on parle de table majeure et table mineure.
Exemple : Nous voulons raliser une table qui associe une personne (nom et prnom) un numro de
tlphone. Il se peut que plusieurs personnes portent le mme nom. Nous faisons un partage de table o
nous associons toutes les personnes portant le mme nom dans la table majeure. Dans la table mineure
nous plaons le prnom et le numro de tlphone. On parle dans ce cas dun rangement partitionn, avec
adressage associatif.

Exemple de partage de table.

Le rangement dispers
Le rangement dispers (hachage) est un rangement o la fonction dadressage est directement calcule. Le
hachage a la particularit de permettre un temps de recherche constant, cest--dire indpendant du nombre
de donnes.
Exemple : On veut grer une table de personnes indexes par leur prnom. A chaque prnom on associe un
entier h(i) de 0 12 en procdant comme suit :
Attribuer aux lettres leur rang dans lalphabet (A->1, B->2, etc.)
Ajouter les valeurs des rangs pour chaque lettre composant le nom i.
Ajouter au nombre obtenu le nombre de lettre de i.
Prendre le reste de la division de ce nombre par 13.
On obtient pour les prnoms : h(serge)=7, h(odile)=11, h(luc)=0, h(anne)=12, h(basile)=2,
h(elise)=3.
On peut placer les prnoms dans un tableau en utilisant comme position la valeur de h(i). Le problme est
que si lon veut insrer paule, on constate que h(paule)=2. On dit quil y a collision primaire entre paule et
basile.
Toute la difficult du hachage consiste :
trouver une fonction de hachage approprie pour viter le plus possible ces collisions
quoi quil en soit il est impossible dviter toujours les collisions (surtout lorsque lensemble dentres est
grand), de ce fait il faut trouver un moyen de rsoudre les collisions sans pour autant augmenter
inconsidrment lespace de mmorisation.
Les fonctions de hachage
Le choix dune bonne fonction de hachage dpend de lensemble dentres sur lequel on travaille
rellement. Par exemple la fonction qui associe une chane le rang de son initiale est uniforme sur
lensemble des chanes possibles mais pas sur lensemble des noms communs franais. Il y a par exemple
plus de mots qui commencent par B que par Z.
Voici quelques types et techniques :
par extraction
On extrait un certain nombre de bits de la reprsentation binaire.
Exemple : extraire les bits 1, 2, 7 et 8 en comptant partir de la droite ET => 00101 10100,
h(ET)=1000=8, IL => 01001 01100, h(IL)=0000=0
Mais ce type de fonction nest pas vraiment bon, car il ne dpend que dune partie des donnes.
Compression
On utilise tous les bits pour obtenir lindice dans le tableau. On coupe les chanes de bits en paquets
dgales longueurs et on les additionne. Pour viter des dbordements il arrive de remplacer laddition par
un XOR :
h(ET)=00101 XOR 10100 = 10001 = (17)10, h(IL)= 01001 XOR 01100 = 00101 = (5)10
Pour viter de hacher de la mme faon toutes les permutations dun mme mot, ici h(IL)=h(LI), on
effectue par exemple des dcalages circulaires (rotations). Par exemple : en dcalant de 1 rang le premier
paquet, de deux le deuxime, etc.
Division
On calcule le reste de la division par un entier n (un nombre dentre dans le tableau) de la codification
binaire :
Exemple avec n=37 : ET = 00101 10100 = (180)10, h(ET) = 180 mod 37 = 32
Malheureusement ce type de fonction dpend fortement de n. Si n est pair, alors tous les lments pairs
vont donner des indices pairs. Si en entre il y plus de pairs que dimpairs cela produit des accumulations.
On est alors amen choisir n premier.

multiplication
Etant donn un nombre rel q, 0 < q < 1, on pose : h(i) = partie entire de (partie dcimale de (i*q)*n), avec q
= 0.6125423371 et n = 30.
h(ET) = partie entire de ( partie dcimale de ( 180*0.6125...)*30) = partie entire de (partie dcimale de
(110.2576...) * 30) = partie entire de (0.2576... * 30) = partie entire de (7.7...) = 7
On remarque que statistiquement on obtient les meilleurs rsultats pour q = (5-1)/2 ou 1-(5-1)/2.
Les fonctions de hachage
sans utiliser de table mineure
Lorsquun lment j est en collision avec i, cest--dire h(i) = h( j), on essaye de placer j en h( j)+1 ( la case
suivante). Si celle-ci est galement occupe, la suivante etc., jusqu trouver un emplacement libre. A
prsent lorsque lon recherche un lment x, ce dernier ne se trouve pas ncessairement en h(x). Il peut se
trouver plus bas. On cherche donc squentiellement jusqu tomber sur x, ou sur une case vide. Un
problme se pose lorsque lon veut effacer un lment. En effet, marquer simplement la case vide coupe
ventuellement le pont pour laccs dautres donnes. Pour cela on utilise un marqueur spcial, de case
libre.
en utilisant une table mineure
On procde comme pour le partage de table.

Exemple de partage de table pour la rsolution de collisions.

Complment : rsolution des conflits de tables de hachages
Par chanage spar

ODILE
MARIE

ALAIN PIERRE

PAUL CECILE NULL

Par chanage avec collision secondaire

1 ODILE -1
2 MARIE -1
3 -1
4 ALAIN 7
5 -1
6 PAUL -1
7 PIERRE 8
8 CECILE -1


Fichiers et entres/sorties
Fichiers physiques, fichiers logiques
Les fichiers sont des entits dans lesquelles on regroupe des informations de manire durable, mme si on
teint l'ordinateur. Cela peut tre un texte, des donnes, un programme, etc. Par exemple, les donnes
concernant les tudiants inscrits dans notre Universit sont crites sur disque, ce qui vite de tout retaper
lors de la r-inscription d'un tudiant. Les donnes sur les clients d'une banque (soldes, mouvements) ne
peuvent pas toutes tre simultanment en mmoire, il est donc ncessaire d'en avoir une partie sur disque,
que l'on pourra charger en mmoire en cas de besoin. pas re-saisies chaque inscription. Un programme
est tap dans un fichier, ce qui vite de le refaire chaque utilisation. Ce cours a t frapp et sauv dans
un fichier, ce qui permet de le faire voluer chaque anne, sans avoir tout retaper.
Assignation
On peut manipuler les fichiers par programme. En fait on ne manipule pas directement les fichiers mais des
variables de type fichier (on appelle a des fichiers logiques, par opposition au fichier physique, sur le disque
dur). Ces variables pourront alors dsigner n'importe quel fichier sur disque. L'opration qui associe une
telle variable un fichier physique s'appelle l'assignation. Cela ressemble l'affectation, sauf qu'ici la variable
ne prend pas comme valeur le nom du fichier (paramtre de l'assignation), mais le fichier sur le disque. Dans
ce chapitre nous ne parlons que des fichiers accs squentiel, prsentant une information par ligne (on par
aussi de fichiers structurs en ligne). Lorsque nous abordons la traduction en C, nous prsentons aussi les
fichiers binaires.
variables
Chane nomDuFichier;
Fichier f;
dbut

f:=assigner(nomDuFichier);

Ouverture
Pour lire des donnes dans un fichier existant, il faut l'ouvrir en lecture. Au contraire, pour crire des
donnes dans un fichier, il faut qu'il ait t ouvert en criture. On ralise ces oprations ainsi :
ouvrirLecture(f);
ouvrirEcriture(f);
En C, l'assignation et l'ouverture d'un fichier sont ralises en un seule opration :
FILE *f;
f = fopen(nomfichier, "r") ; // Ouverture en lecture
f = fopen(nomfichier, "w") ; // Ouverture en criture
Dans le cas d'une ouverture en criture, si le fichier existe alors son contenu est perdu.
On peut ajouter b au mode d'ouverture, pour prciser qu'il s'agit de donnes binaires, et viter les problmes
dus la diffrence de codage du caractre retour-chariot ('\n') sur certains systmes (MSDOS).
"rb" = lire des donnes binaires.
"wb" = crire des donnes binaires.
Il existe d'autres modes d'ouverture :
"a" = ouverture en allongement.
"a+" = ouverture en allongement, permet aussi la lecture.
"r+" = mise jour : permet de lire et crire dans un fichier pour le modifier mais on ne peut pas en
augmenter la taille.
"w+" = ouverture en criture, mais permet aussi la lecture.
fopen rend NULL en cas d'chec (fichier inexistant, pas de droit d'accs en criture, etc.)
FILE *f ;
char *monfichier="donnees.txt";
f = fopen(nomfichier, "r");
if (f == NULL){
fprintf(stderr,"erreur ouverture %s en lecture\n", nomfichier) ;
exit(1);
}

On peut crire une macro pour avoir ce message d'erreur (et l'arrt du programme) quand il y a chec lors
de l'ouverture d'un fichier quelconque :
#define FOPEN(f,nf,mode) { f=fopen(nf,mode); \
if(f == NULL) { \
fprintf(stderr, "erreur ouverture %s\n",nf) ;\
exit(1);\
}}
Remarque : dans une macro tout doit tre crit sur la mme ligne, sauf si on utilise un backslash ( \ ). C'est
lors de l'utilisation de cette macro que l'on spcifie le fichier et le mode, par exemple FOPEN(f,
nomfichier, "r");
Entres/Sorties formates
Lecture
La lecture dans un fichier se fait selon un accs squentiel : le premier ordre de lecture (liref) lit la premire
donne prsente, le deuxime la suivante et ainsi de suite. Cela implique que lordre des instructions de
lecture doit respecter dans lequel sont ranges les donnes. Il y a principalement 2 faons d'organiser la
lecture, selon que l'on connat ou non l'avance le nombre de donnes prsentes.
Si on connat le nombre de donnes, la lecture de toutes les donnes se fait au moyen d'un boucle pour.
Dans l'exemple suivant, le nombre de donnes est la premire donne du fichier. Suivent ensuite autant de
nombres entiers qu'indiqu en entte. Pour certaines applications, la taille du fichier est toujours la mme, il
est donc inutile de le prciser en prambule. Ci suit une fonction d'initialisation de tableau d'entiers partir
de donnes contenues dans un fichier. En paramtre de cette fonction, nous trouvons le nom du fichier ainsi
que la taille maximale du tableau.
fonction lireTableauDansFichier(chane nomDuFichier; entier taillemax) : (tableau entier, entier)
variables
Fichier f;
entier nbDonnes, i, laDonne;
tableau entier[TAILLEMEAX] tab;
dbut
f := assigner(nomDuFichier);
ouvrirLecture(f);
nbDonnes := liref(f);
si nbDonnes > taillemax alors nbDonnes := taillemax;
faire pour i depuis 1 jusque nbDonnes
laDonne := liref(f);
tab[i-1] := laDonne;
fait
fermer(f);
lireTableauDansFichier := (tab, nbDonnes);
fin
Si au contraire on l'ignore, on va lire les donnes jusqu' atteindre la fin du fichier :
fonction lireTableauDansFichier(chane nomDuFichier; entier taillemax) : (tableau entier, entier)
variables
Fichier f;
Chane nomDuFichier;
entier nbDonnes init 0;
tableau entier[TAILLEMEAX] tab;
dbut
ouvrirLecture(f)
tant que NON finDeFichier(f) faire
tab[nbDonnes] := liref(f);
nbDonnes := nbDonnes+1;
fait
fermer(f);
lireTableauDansFichier := (tab, nbDonnes);
fin


Ecriture
Comme pour la lecture, les donnes sont crites les unes aprs les autres dans le fichier, exactement
comme cela se passe lorsque l'on affiche l'cran.
procdure ecrireTableauDansFichier(chane nomDuFichier; tableau entier tab[taillemax]; entier taille)
variables
Fichier f;
entier nbDonnes;
dbut
ouvrirEcriture(f);
ecriref(f, taille);
faire pour i depuis 1 jusque nbDonnes
ecriref(f,tab[i]);
fait
fermer(f);
fin
Lecture et criture formates en C
Il existe 3 fichiers prdfinis et dj ouverts, stdin le fichier d'entre standard, stdout le fichier de sortie
standard et stderr le fichier d'erreur standard. Ce deuxime fichier de sortie permet de sparer les
messages qui sont des rsultats de ceux qui sont l pour informer l'utilisateur, ou l'avertir d'erreurs. Nous
avons dj utilis stdout et stdin implicitement (sauf pour stdin que nous avons utilis explicitement
avec feof(stdin)) :
scanf("%d",&x); est identique fscanf(stdin,"%d",&x);
printf("%d",x); est identique fprintf(stdout,"%d",x);
Ainsi, pour lire un entier dans un fichier Ascii f ouvert par fopen, on utilise : fscanf(f,"%d",x);
Pour crire un entier (sous forme de texte) dans un fichier f ouvert par fopen, on crira :
fprintf(f,"%d",x);
Fermeture d'un fichier
Cette opration est ncessaire avant la fin d'un programme. Une fois ferm, le fichier logique peut tre
assign un autre fichier physique, et donc tre r-ouvert.
fermer(f);
en C :
fclose(f);
Fichiers binaires
Lecture et criture binaires en C
En C, il est possible de manipuler directement les donnes, sans passer par la conversion en mode texte.
Lorsque les donnes sont trs volumineuses, les entres et sorties deviennent alors beaucoup plus rapides.
Pour recopier tel quel (en binaire) dans un fichier : fwrite
Syntaxe : fwrite((char *) &x, sizeof(int), 1, f);
Les paramtres de fwrite sont un pointeur sur un caractre (si on a un entier ou un autre type, on force la
conversion), la taille d'un lment, le nombre d'lments et le nom du fichier dans lequel on crit.
int tabint[100] ;
fwrite((char *) tabint, sizeof(int), 100, f) ;
Pour relire le tableau recopi tel quel : fread
fread((char *) tabint, sizeof(int), 100, f);
Il faut avoir bien auparavant dclar ou allou un tableau suffisamment grand.

Il existe d'autres fonctions sur les fichiers, parmi lesquelles :
fseek qui permet de se placer directement l'endroit modifier ou lire. Pour se placer sur le 100 me
entier du fichier :
fseek(f, (100 - 1) * sizeof(int), SEEK_SET) ;
ftell permet de savoir quel endroit on se trouve dans le fichier : ftell(f) ;

Application : sauvegarde d'un tableau
Cet exemple remplit un tableau et le copie en binaire dans un fichier avec en plus en entte sa taille en clair.
#include <stdio.h>
#include <stdin.h>
#define N 1000
main()
{
int tabint[N] ;
int nbval ;
FILE *f ;
char nomfichier[20] ;
nbval = initTableau(tabint, N) ;
fprintf(stdout, "Entrez un nom de fichier de donnes binaires : ") ;
fscanf(stdin, "%s", nomfichier) ;
f = fopen(nomfichier, "w") ;
fprintf(f, "%d\n", nbval) ;
fwrite((char *) tabint, sizeof(int), nbval, f) ;
fclose(f) ;
}
Pour lire ce fichier (qui est illisible avec un diteur de texte), et rcuprer la taille en clair :
#include <stdio.h>
#define N 1000
main()
{
int tabint[N] ;
int nbval ;
FILE *f ;
fprintf(stdout, "Entrez un nom de fichier : ") ;
f = fopen(nomfichier, "r") ;
fscanf(f, "%d", &nbval) ;
fread((char *) tabint, sizeof(int), nbval, f) ;
fclose(f) ;
}
Une autre mthode est de lire entirement la premire ligne du fichier, puis de lire dans cette ligne comme
dans un fichier.
#include <stdio.h>
#define N 1000
#define tailleligne 100
main()
{
int tabint[N] ;
int nbval ;
FILE *f ;
char ligne[tailleligne] ;
fprintf(stdout, "Entrez un nom de fichier : ") ;
f = fopen(nomfichier, "r") ;
fgets(ligne, tailleligne, f) ; /* lit toute une ligne */
sscanf(ligne, "%d", &nbval) ; /* lecture dans une chane */
fread((char *) tabint, sizeof(int), nbval, f) ;
fclose(f) ;
}

Introduction la cinmatique des fichiers


Les listes chanes

Gnralits
Les listes offrent un moyen de reprsenter une collection d'informations de mme type avec un certain
nombre d'avantages sur les tableaux : leur gestion est plus simple, en particulier lorsque le nombre
d'lments n'est pas connu l'avance et connat de nombreuses volutions pendant la dure de l'excution
du programme, du fait que ces informations ne sont pas ncessairement contigus en mmoire, au contraire
des tableaux. Une liste est une suite d'lments du mme type, et est dfinie de manire rcursive en
distinguant les deux cas :
la liste est vide, ne contient aucun lment ;
la liste n'est pas vide, elle est forme de 2 composantes :
la premire composante est le premier lment de la liste ;
la deuxime composante est la liste forme de tous les lments suivant le premier.
D'un point de vue symbolique, on peut reprsenter la liste comme un couple, la liste vide tant simplement
note par des parenthses vides : (). Toute liste contenant un lment prendra comme forme (a,()), une liste
deux lments ressemblera (a,(b,())) et ainsi de suite. La plupart des algorithmes de manipulation de
liste pourront s'exprimer naturellement sous forme rcursive, en diffrenciant les 2 cas :
si la liste est vide, on n'effectue aucun traitement ;
si elle n'est pas vide, elle possde 2 composantes, la premire tant le premier lment. On applique
alors le traitement en question ce premier lment, et on appelle de manire rcursive l'excution de
l'algorithme sur la sous-liste contenue dans la deuxime composante.
Le type liste
Lorsque le type liste est support par un langage de programmation, un certain nombre de fonctions
lmentaires sont disponibles qui permettent non seulement d'accder facilement l'une ou l'autre des
composantes, mais aussi de construire une liste, partir d'un lment et d'une liste. Hlas, le type liste
n'existe pas en langage C. On imagine toutefois qu' l'aide du constructeur de structures, il serait possible
de le dfinir. Il faut toutefois faire trs attention, car en C dfinir un type n'est possible que si on est capable
de calculer la taille des informations qu'il dcrit. Or on ne connat pas la taille d'une liste, puisqu'elle dpend
de la taille de sa deuxime composante, elle mme une liste. C'est pourquoi en C on ne peut dfinir une
structure l'aide du type qu'on est en train de dfinir, enfin pas aussi brutalement, sans quoi la structure
ainsi dcrite aurait une taille infinie. Mme en usant du constructeur union pour prvoir le cas de la liste
vide, on ne rsout pas le problme, car le compilateur rserve l'espace mmoire ncessaire pour stocker le
plus grand des champs de l'union, donc ne prend jamais en compte le cas de la liste vide. La solution
consiste modliser la deuxime composante de la liste par un pointeur sur une liste. On rsout ainsi le
problme de la taille : que cette composante soit vide ou non, elle est toujours dcrite par un pointeur, qui s'il
est diffrent de NULL rfrence une liste non vide. On dfinit alors une liste comme une structure deux
composantes, l'une tant l'information proprement dite, l'autre un pointeur vers la liste suivante, donc
l'lment suivant. En fait il est prfrable de ne pas embarquer l'information pertinente directement dans la
structure, mais plutt de se contenter d'un pointeur sur l'information, ce qui permet de gnraliser plus
facilement l'utilisation des listes. La structure suivante dcrit une Cellule comme un constituant de base de
la liste, qui possde 2 champs, l'information utile (ou mieux un pointeur vers cette information) et un pointeur
sur la liste suivante. Comme on dfinit le type Liste comme un pointeur sur une telle structure, le champ
pointeur sur une cellule est donc bien une liste, comme tout pointeur sur une cellule. La liste vide est
simplement ralise l'aide la valeur NULL : qui ne pointe sur aucune cellule.
typedef struct t_liste {
Info element;
struct t_liste *suivant;
} Cellule, *Liste;
laquelle on prfrera
Info *element;
} Cellule, *Liste;
o Info est le type des informations utiles contenues dans la liste.

Oprations lmentaires sur les listes
Les oprations dclaration, test de vacuit, construction, extraction de composantes sont possibles dans de
nombreux langages. partir de ces quelques oprations essentielles, on peut raliser toutes les oprations
possibles sur les listes. Comme en C ces fonctionnalits de base n'existent pas, nous allons les raliser.
Dclaration et initialisation
On la ralise l'aide de l'instruction Liste l = initListeVide() ; ou Liste l = uneListe ;.
Attention, dans ce dernier cas, l est une liste initialise la valeur de la liste uneListe. Comme il s'agit de
pointeurs, l est une copie de l'adresse du premier lment de uneListe, et non pas une copie de la liste
entire. En consquence, modifier la liste l va entraner la mme modification sur uneListe. Attention aux
effets de bord !
/* -------------------------------------------------------------------------- */
/* Initialisation d'une liste Vide */
/* Entre : Nant, Modifiable : Nant */
/* Sortie : Liste vide */
/* Globales lues : Nant, Globales modifies : Nant */
/* -------------------------------------------------------------------------- */
Liste initListeVide(void)
{
return NULL;
}
Test de vacuit
Une liste est vide si elle vaut NULL :
/* -------------------------------------------------------------------------- */
/* Teste si une liste est vide */
/* Entre : une liste l */
/* Modifiable : Nant */
/* Sortie : entier, nul si la liste n'est pas vide */
/* -------------------------------------------------------------------------- */
int listeVide(Liste l)
{
return (l==NULL);
}
Accs la premire information de la liste : la tte
La fonction suivante dlivre l'adresse de la premire cellule de la liste. Cette fonction ne doit pas tre utilise
avec une liste vide. Il reste ensuite accder au champ Info de la cellule, et aux informations qu'il contient.
/* -------------------------------------------------------------------------- */
/* Dlivre la tte de la liste */
/* Sortie : la premire cellule (pointeur) */
/* -------------------------------------------------------------------------- */
Cellule *tete(Liste l)
{
if (listeVide(l)) sortirSurErreur("Tete");
return l;
}
Accs la deuxime composante : la queue
Ceci n'est possible que si la liste n'est pas vide.
/* -------------------------------------------------------------------------- */
/* Dlivre la queue de la liste */
/* Sortie : la queue de la liste */

/* -------------------------------------------------------------------------- */
Liste queue(Liste l)
{
if (listeVide(l)) sortirSurErreur("Queue");
return l->suivant;
}
Ajout d'un lment en tte
L'ajout d'un lment en tte est l'opration essentielle sur les listes, est appele aussi constructeur, dlivre
une liste, partir d'un lment et d'une liste. Il suffit de faire pointer le champ suivant du nouvel lment de
tte vers l'ancienne liste, qui devient ainsi la queue de la nouvelle.
/* -------------------------------------------------------------------------- */
/* Ajout d'une cellule en tte d'une liste */
/* Entre : pointeur sur cellule, liste */
/* Sortie : la nouvelle liste obtenue par l'ajout en tte */
/* -------------------------------------------------------------------------- */
Liste constructeur(Cellule *c, Liste l)
{
if (c != NULL)
c->suivant = l;
return c;
}
Suppression de l'lment en tte
Une opration importante est la suppression d'informations pouvant tre contenues dans une liste. En
thorie, cette opration n'est pas indispensable, puisqu'il suffit d'accder la queue de la liste pour liminer
par oubli la tte : l = queue (l) ;
En C, il n'existe pas de ramasse-miettes donc la mmoire occupe par la cellule limine, bien qu'elle ne
soit plus rfrence, n'est pas automatiquement libre. Pour la rendre rutilisable, il faut librer (on dit aussi
parfois ds-allouer) explicitement cette mmoire. Vous noterez que pour assurer la gnralit de ce
traitement, la fonction de ds-allocation de l'information utile est passe en paramtre de la fonction de
suppression de tte. videmment, la suppression du premier lment de la liste n'est possible que si la liste
n'est pas vide. Auquel cas, la liste obtenue est celle dsigne par le champ suivant de la tte de la liste.
/* -------------------------------------------------------------------------- */
/* Suppression de la premire cellule d'une liste */
/* Entre : liste, fonction de destruction de cellule */
/* Sortie : la nouvelle liste obtenue par suppression de la tte */
/* -------------------------------------------------------------------------- */
Liste supprimeTete(Liste l, void(*lc)(Cellule *))
{
Cellule *t;

if (!listeVide(l)) {
t = l;
l = l->suivant;
lc(t);
}
return l;
}
Un exemple de fonction de destruction de cellule correspondant au deuxime type de liste que nous avons
dfini est donn :
/* -------------------------------------------------------------------------- */
/* Fonction de destruction de cellule */
/* Entre : pointeur sur une cellule */
/* Sortie : Nant */
/* -------------------------------------------------------------------------- */

void libereCellule(Cellule *c)
{
free(c->info);
free(c);
}
Autres oprations utiles sur les listes : notion de type abstrait
Les fonctions suivantes ne ncessitent pas de connatre la structure de donnes interne de la liste, il suffit
de les manipuler l'aide des fonctions dfinies ci-dessus. Elles sont donnes directement en langage C.
Longueur d'une liste
Le nombre d'lments d'une liste (appel aussi taille ou longueur) est obtenu par l'algorithme : si la liste est
vide, sa longueur est nulle, sinon elle contient au moins un lment. On peut mme dire que sa longueur est
1 (on comptabilise le premier lment) plus la longueur de la deuxime composante (la liste des autres
lments).
/* -------------------------------------------------------------------------- */
/* Calcul de la longueur d'une liste (nombre d'lments) */
/* Entre : liste */
/* Sortie : nombre entier d'lments */
/* -------------------------------------------------------------------------- */
int longueurListe(Liste l)
{
int lg;

if (listeVide(l)) lg = 0;
else lg = 1 + longueurListe(queue(l));

return lg;
}
Ajout en queue
Grce la fonction constructeur, il est possible de faire d'autres fonctions d'ajout d'lments dans des listes.
En particulier, l'ajout en queue de liste est ralis en utilisant la stratgie rcursive suivante : Si la liste est
vide, l'ajout en queue n'est autre qu'un ajout en tte. Sinon on cherchera raliser l'ajout de queue de la
deuxime composante de la liste en entre. Attention ne pas casser la liste, c'est--dire rompre le
chanage entre la tte et le corps de la liste :
/* -------------------------------------------------------------------------- */
/* Ajout d'une cellule en queue de liste */
/* Entre : pointeur sur cellule, liste */
/* Sortie : la nouvelle liste aprs ajout */
/* -------------------------------------------------------------------------- */
Liste ajoutQueue(Cellule *c, Liste l)
{
Liste l2;

if (listeVide(l))
l2 = constructeur(c, l);
else
l2 = constructeur(tete(l), ajoutQueue(c, queue(l)));

return l2;
}
Suppression du dernier lment
La suppression du dernier lment de la liste quivaut la suppression de la tte, en prsence d'un lment
unique. On doit alors vrifier si on ce trouve dans ce cas. Dans le cas contraire, on tentera d'ter le dernier
lment de la deuxime composante de la liste.

/* -------------------------------------------------------------------------- */
/* Suppression de la dernire cellule d'une liste */
/* Entre : liste, fonction de destruction de cellule */
/* Sortie : la nouvelle liste obtenue par suppression */
/* -------------------------------------------------------------------------- */
Liste supprimeQueue(Liste l, void(*lc)(Cellule *))
{
Liste l2;
/* si la liste est vide on ne supprime rien */
/* si la liste n'a qu'un seul lment : idem supprimeTete */
if (listeVide(queue(l)))
l2 = supprimeTete(l, lc);
else
l2 = constructeur(tete(l), supprimeQueue(queue(l), lc));
}
else l2 = initListeVide();
return l2;
}
Insertion en une position donne
Pour insrer un lment une position donne, on fait l encore appel au constructeur de liste. Si on n'est
pas dans le cas idal d'ajout en position initiale, on tente de s'y ramener en invoquant l'appel de la fonction
applique la deuxime composante de la liste, et en faisant diminuer en mme temps la position : insrer
en position n d'une liste, c'est insrer en position n-1 de sa sous-liste. Dans cette autre version, nous avons
rendu possible l'insertion, mme si la position prconise n'est pas valide : en tte si n<1, en queue si n
dpasse la taille de la liste.
/* -------------------------------------------------------------------------- */
/* Ajout (si possible) d'un lment une position donne */
/* Entre : liste, pointeur sur cellule, position (entire) */
/* Sortie : la nouvelle liste obtenue par insertion */
/* -------------------------------------------------------------------------- */
Liste ajoutPosition(Liste l, Cellule *c, int n)
{
Liste l2;
if (n<1) l2 = l;
else if (n==1) l2 = constructeur(c, l);
else if (!listeVide(l))
l2 = constructeur(tete(l), ajoutPosition(queue(l), c, n-1));
return l2;
}

/* -------------------------------------------------------------------------- */
/* Ajout (toujours possible) d'un lment une position donne */
/* Entre : liste, pointeur sur cellule, position (entire) */
/* -------------------------------------------------------------------------- */
Liste ajoutPositionV2(Liste l, Cellule *c, int n)
{
Liste l2;
if ( (n<1) || (listeVide(l)) ) l2 = constructeur(c, l);
else
l2 = constructeur(tete(l), ajoutPositionV2(queue(l), c, n-1));
return l2;
}

Suppression d'un lment de position donne
De la mme manire, la suppression d'un lment de position donne n'est simple que s'il s'agit du premier
lment. Si tel n'est pas le cas, on tente alors d'oprer la suppression au sein de la deuxime composante,
en ayant soin de faire varier correctement la valeur de la position concerne par la suppression.
/* -------------------------------------------------------------------------- */
/* Suppression (si possible) d'un lment une position donne */
/* Entre : liste, position (entire), fonction de destruction de cellule */
/* Sortie : la nouvelle liste obtenue par suppression */
/* -------------------------------------------------------------------------- */
Liste supprimePosition(Liste l, int n, void(*lc)(Cellule *c))
{
Liste l2;
if (n<1) l2 = l;
else if (n==1) l2 = supprimeTete(l, lc);
else if (!listeVide(l))
l2 = constructeur(tete(l), supprimePosition(queue(l), n-1, lc));
return l2;
}
Insertion trie (ou sur critre quelconque)
L'ajout tant trivial dans le cas d'une liste vide, on peut se concentrer sur le cas des listes non vides : si
l'ajout en tte permet de maintenir la relation d'ordre (dcrite par une fonction passe en paramtre pour
assurer un maximum de gnralit), on le pratique, sinon on renouvelle la tentative d'insertion, mais cette
fois dans la deuxime composante de la liste.
/* -------------------------------------------------------------------------- */
/* Insertion cellule dans une liste avec maintien d'une relation d'ordre */
/* Entre : liste, pointeur sur cellule, relation d'ordre entre 2 cellules */
/* -------------------------------------------------------------------------- */
Liste ajoutTri(Liste l, Cellule *c, int(*oc)(Cellule *, Cellule *))
{
Liste l2;
if (listeVide(l)) l2 = constructeur(c, l);
else {
if ((!oc(c, tete(l)))
l2 = constructeur(tete(l), ajoutTri(queue(l), c, oc));
else l2 = constructeur(c, l);
}
return l2;
}
Si on veut effectuer un tri croissant sur une liste d'entiers, on utilisera une relation d'ordre dfinie comme
suit :
int ordreCellule(Cellule *a, Cellule *b)
{
return ( (*(a->info)).v < (*(b->info)).v );
}
Exemple d'utilisation
Voici un petit programme qui illustre l'usage de fonctions de manipulation de listes, tout en tant aussi
gnrique que possible. Nous dfinissons le type des lments de la liste (dans le fichier infoT.h)
infoT.h
typedef struct t_info {
int v;
} Info;


La dfinition de notre type Liste dans le fichier listeT.h reste inchange, seul le type Info ayant besoin d'tre
modifi.
listeT.h
#include "infoT.h"

typedef struct t_cellule {
Info *info;
struct t_cellule *suivant;
} Cellule, *Liste;
Quant au fichier listeP.h, il contient les prototypes des fonctions de manipulation de liste. :
listeP.h
extern Liste initListeVide(void);
extern int listeVide(Liste l);
extern Liste queue(Liste l);
extern Liste constructeur(Cellule *c, Liste l);
extern Liste supprimeTete(Liste l, void(*lc)(Cellule *));
extern int longueurListe(Liste l);
extern Liste ajoutQueue(Cellule *c, Liste l);
extern Liste supprimeQueue(Liste l, void(*lc)(Cellule *));
extern Liste ajoutPosition(Liste l, Cellule *c, int n);
extern Liste ajoutPositionV2(Liste l, Cellule *c, int n);
extern Liste supprimePosition(Liste l, int n, void(*lc)(Cellule *c));
extern Liste ajoutTri(Liste l, Cellule *c, int(*oc)(Cellule *, Cellule *));
Voici enfin le petit applicatif qui manipule des listes :
appliListe.c
#include <stdio.h>
#include <stdlib.h>

#include "infoT.h"
#include "listeT.h"
#include "listeP.h"

Cellule * nouvelleCellule(int v)
{
Cellule *c;

c = (Cellule *)malloc(sizeof(Cellule));
c->info = (Info *)malloc(sizeof(Info));
(*(c->info)).v = v;
return c;
}

int ordreCellule(Cellule *a, Cellule *b)
{
return ( (*(a->info)).v < (*(b->info)).v );
}

void libereCellule(Cellule *c)
{
free(c->info); free(c);
}

void afficheListe(Liste l)
{
fprintf(stderr,"%d ",(*(l->info)).v);
afficheListe(queue(l));
}
else fprintf(stderr,"\n");
}

/* PROGRAMME PRINCIPAL */
/* ################### */

int main(int argc, char **argv)
{
Liste l;
Cellule *c;

l = initListeVide();
c = nouvelleCellule(4);
l = ajoutTri(l, c, ordreCellule);
l = supprimeTete(l, libereCellule);
l = ajoutPosition(l, c, 5);
afficheListe(l);
}
Structures rcursives et croises
Chanages multiples

Les piles
Modlisation de la structure
Introduction
Une pile est une structure qui stocke de manire ordonne des lments, mais rend accessible uniquement
un seul d'entre eux, appel le sommet de la pile. Quand on ajoute un lment, celui-ci devient le sommet de
la pile, c'est--dire le seul lment accessible. Quant on retire un lment de la pile, on retire toujours le
sommet, et le dernier lment ajout avant lui devient alors le sommet de la pile. Pour rsumer, le dernier
lment ajout dans la pile est le premier lment en tre retir. Cette structure est galement appele
une liste LIFO (Last In, First Out).
Gnralement, il y a deux faons de reprsenter une pile. La premire s'appuie sur la structure de liste
chane vue prcdemment. La seconde manire utilise un tableau.
Modlisation par liste chane
La premire faon de modliser une pile consiste utiliser une liste chane en n'utilisant que les oprations
ajouterTete et retirerTete. Dans ce cas, on s'aperoit que le dernier lment entr est toujours le premier
lment sorti. La figure suivante reprsente une pile par cette modlisation. La pile contient les chanes de
caractres suivantes qui ont t ajoutes dans cet ordre: "Paris", "Marseille", "Bordeaux", "Lyon" et
"Toulouse".

Pour cette modlisation, la structure d'une pile est celle d'une liste chane.

Modlisation par tableau
La deuxime manire de modliser une pile consiste utiliser un tableau. L'ajout d'un lment se fera la
suite du dernier lment du tableau. Le retrait d'un lment de la pile se fera en enlevant le dernier lment
du tableau. La figure suivante reprsente une pile par cette modlisation. Elle reprend la mme pile que pour
l'exemple de modlisation par liste chane.

Voici la structure de donnes correspondant une pile reprsente par un tableau.
typedef struct {
ELEMENT tab[NMAX];
ENTIER n;
} PILE_TAB ;
NMAX est une constante reprsentant la taille du tableau allou. n est le nombre d'lments dans la pile.
Oprations sur la structure
Introduction
A partir de maintenant, nous allons employer le type PILE qui reprsente une pile au sens gnral, c'est--
dire sans se soucier de sa modlisation. PILE reprsente aussi bien une pile par liste chane (PILE_LST)
qu'une liste par pointeurs (PILE_PTR). Voici les oprations que nous allons dtailler pour ces deux
modlisations.
fonction initialiserPile() : PILE
Initialise une pile vide.

fonction pileVide(PILE p) : BOOLEEN
Indique si la pile p est vide.
fonction sommet(PILE p) : ELEMENT
Retourne l'lment au sommet de la pile p
fonction empilerElement(PILE p, ELEMENT e) : PILE
Empile l'lment e au sommet de la pile p.
fonction depilerElement(PILE p) : (PILE, ELEMENT)
Dpile et dlivre l'lment au sommet de la pile p. La nouvelle pile est aussi dlivre.

Les prototypes de ces oprations (paramtres et type de retour) sont les mmes quelque soit la
modlisation choisie.
Oprations pour la modlisation par liste chane
Initialiser la pile
Cette fonction initialise les valeurs de la structure reprsentant la pile, afin que celle-ci soit vide. Dans le cas
d'une reprsentation par liste chane, il suffit d'initialiser la liste chane qui reprsente la pile.
fonction initialiserPile():PILE
dbut
initialiserPile := initialiserListe();
fin
Pile vide ?
Cette fonction indique si la pile p est vide. Dans le cas d'une reprsentation par liste chane, la pile est vide
si la liste qui la reprsente est vide.
fonction pileVide(PILE p): BOOLEEN
dbut
pileVide := listeVide(p);
fin
Sommet d'une pile
Cette fonction retourne l'lment au sommet de la pile p. Dans le cas d'une reprsentation par liste chane,
cela revient retourner la valeur de l'lment en tte de la liste. A n'utiliser que si la pile p n'est pas vide.
fonction sommet(PILE p): ELEMENT
variables
ELEMENT res init NIL;
dbut
si (non pileVide(p)) alors res := teteListe(p); finsi
sommet := res ;
fin
Empiler un lment sur une pile
Cette fonction empile l'lment e au sommet de la pile p. Pour la reprsentation par liste chane, cela
revient ajouter l'lment e en tte de la liste.
fonction empilerElement(PILE p, ELEMENT e): PILE
dbut
empilerElement := ajouterTete(p,e);
fin
Dpiler un lment d'une pile
Cette fonction dpile l'lment au sommet de la pile p et stocke sa valeur dans e. Pour la reprsentation par
liste chane, cela revient rcuprer (si possible) la valeur de l'lment en tte de liste avant de le
supprimer de cette dernire.
fonction depilerElement(PILE p): (PILE, ELEMENT)
variables
ELEMENT e init NIL;
dbut
si (non pileVide(p)) alors e := sommet(p) ; p := retirerTete(p); finsi
depilerElement := (p, e) ;
fin

Oprations pour la modlisation par tableau
Initialiser la pile
Cette fonction initialise les valeurs de la structure reprsentant une pile, afin que celle-ci soit vide. Dans le
cas d'une reprsentation par tableau, il suffit de rendre n nul.
fonction initialiserPile():PILE
variables
PILE p ;
dbut
p .n := 0;
initialiserPile := p ;
fin
Pile vide ?
Cette fonction indique si la pile p est vide. Dans le cas d'une reprsentation par tableau, la pile est vide si le
champ n est nul.
fonction pileVide(PILE p): BOOLEEN
dbut
pileVide := (p.n = 0);
fin
Sommet d'une pile
Cette fonction retourne l'lment au sommet de la pile p. Dans le cas d'une reprsentation par tableau, cela
revient retourner la valeur du nime lment du tableau (i.e. l'lment d'indice n - 1). A n'utiliser que si la
pile p n'est pas vide.
fonction sommet(PILE p): ELEMENT
variables
ELEMENT e init NIL ;
dbut
si (non pileVide(p)) alors e := (p.tab[p.n - 1]); finsi
sommet := e ;
fin
Empiler un lment sur une pile
Cette fonction empile l'lment e au sommet de la pile pointe par p. Pour la reprsentation par tableau, cela
revient ajouter l'lment e la fin du tableau. S'il reste de la place dans l'espace rserv au tableau,
lempilement peut avoir lieu.
variables
PILE res init p ;
dbut
si (res.n < NMAX) alors res.tab[res.n] :=e; res.n := res.n + 1; finsi
empilerElement :=res ;
fin

dbut
si (p.n < NMAX) alors p.tab[p.n] :=e; p.n := p.n + 1; finsi
empilerElement :=res ;
fin
Dpiler un lment d'une pile
Cette fonction dpile l'lment au sommet de la pile p et stocke sa valeur dans e. Pour la reprsentation par
tableau, cela revient diminuer d'une unit le champ n, et renvoyer l'lment d'indice n du tableau. Si la
pile n'est pas dj vide, on peut dpiler.
fonction depilerElement(PILE p) : (PILE, ELEMENT)
variables
ELEMENT e init NIL;

dbut
si (non (pileVide(p))) alors e := sommet(p); p.n := p.n - 1; finsi
depilerElement := (p, e) ;
fin
Conclusion
Comme la pile ne permet l'accs qu' un seul de ses lments, son usage est limit. Cependant, elle peut
tre trs utile pour supprimer la rcursivit d'une fonction. La diffrence entre la modlisation par liste
chane et la modlisation par tableau est trs faible. L'inconvnient du tableau est que sa taille est fixe
l'avance, contrairement la liste chane qui n'est limite que par la taille de la mmoire centrale de
l'ordinateur. En contrepartie, la liste chane effectue une allocation dynamique de mmoire chaque ajout
d'lment et une libration de mmoire chaque retrait du sommet de la pile. En rsum, la modlisation
par liste chane sera un peu plus lente, mais plus souple quant sa taille.

Les files
Modlisation de la structures
Introduction
Une file d'attente est une structure qui stocke de manire ordonne des lments, mais rend accessible
uniquement un seul d'entre eux, appel la tte de la file. Quant on ajoute un lment, celui-ci devient le
dernier lment qui sera accessible. Quant on retire un lment de la file, on retire toujours la tte, celle-ci
tant le premier lment qui a t plac dans la file.
Pour rsumer, le premier lment ajout dans la pile est le premier lment en tre retir. Cette structure
est galement appele une liste FIFO (First In, First Out). Gnralement, il y a deux faons de reprsenter
une file d'attente. La premire s'appuie sur la structure de liste chane vue prcdemment. La seconde
manire utilise un tableau d'une faon assez particulire que l'on appelle modlisation par "tableau
circulaire".
Modlisation par liste chane
La premire faon de modliser une file d'attente consiste utiliser une liste chane en n'utilisant que les
oprations ajouterQueue et retirerTete. Dans ce cas, on s'aperoit que le premier lment entr est toujours
le premier lment sorti. La figure suivante reprsente une file d'attente par cette modlisation. La file
contient les chanes de caractres suivantes qui ont t ajoutes dans cet ordre: "Paris", "Marseille",
"Bordeaux", "Lyon" et "Toulouse".

Pour cette modlisation, la structure d'une file d'attente est celle d'une liste chane (avec tte et queue).
Modlisation par tableau circulaire
La deuxime manire de modliser une file d'attente consiste utiliser un tableau. L'ajout d'un lment se
fera la suite du dernier lment du tableau. Le retrait d'un lment de la file se fera en enlevant le premier
lment du tableau. Il faudra donc deux indices pour ce tableau, le premier qui indique le premier lment
de la file et le deuxime qui indique la fin de la file. La figure suivante reprsente une file d'attente par cette
modlisation. Elle reprend la mme pile que pour l'exemple de modlisation par liste chane.

On peut noter que progressivement, au cours des oprations d'ajout et de retrait, le tableau se dplace sur
la droite dans son espace mmoire. A un moment, il va en atteindre le bout de l'espace. Dans ce cas, le
tableau continuera au dbut de l'espace mmoire comme si la premire et la dernire case taient
adjacentes, d'o le terme "tableau circulaire". Ce mcanisme fonctionnera tant que le tableau n'est
effectivement pas plein. Pour illustrer, reprenons l'exemple prcdent auquel on applique trois oprations de
retrait de l'lment de tte. On ajoute galement en queue les lments suivants et dans cet ordre:
"Orlans", "Nantes", "Poitiers", "Nice".

La file d'attente contient alors, et dans cet ordre: "Lyon", "Toulouse", "Orlans", "Nantes", "Poitiers" et "Nice".
On s'aperoit que, ayant atteint la fin du tableau, la file redmarre l'indice 0.
Voici la structure de donnes correspondant une file d'attente reprsente par un tableau circulaire.

typedef struct {
ELEMENT tab[NMAX];
ENTIER tete;
ENTIER fin;
} FILE_TAB;
NMAX est une constante reprsentant la taille du tableau allou. tete est l'indice de tableau qui pointe sur la
tte de la file d'attente. fin est l'indice de tableau qui pointe sur la case suivant le dernier lment du tableau,
c'est--dire la prochaine case libre du tableau.
Oprations sur la structure
Introduction

A partir de maintenant, nous allons employer le type FILE qui reprsente une file d'attente au sens gnral,
c'est--dire sans se soucier de sa modlisation. FILE reprsente aussi bien une file d'attente par liste
chane (FILE_LST) qu'une file d'attente par tableau circulaire (FILE_TAB). Voici les oprations que nous
allons dtailler pour ces deux modlisations.
fonction initialiserFile() : FILE
Initialise une file vide.
fonction fileVide(FILE f) : BOOLEEN
Indique si la file f est vide.
fonction teteFile(FILE f) : ELEMENT
Retourne l'lment en tte de la file f.
fonction entrerElement(FILE f, ELEMENT e) : FILE
Entre l'lment e dans la file f.
fonction sortirElement(FILE f) : (FILE, ELEMENT)
Sort l'lment en tte de la file f.
Les prototypes de ces oprations (paramtres et type de retour) sont les mmes quelque soit la
modlisation choisie.
Oprations pour la modlisation par liste chane
Initialiser une file
Cette fonction initialise les valeurs de la structure reprsentant la file f pour que celle-ci soit vide. Dans le cas
d'une reprsentation par liste chane, il suffit d'initialiser la liste chane qui reprsente la file d'attente.
fonction initialiserFile():FILE
dbut
initialiserFile := initialiserListe();
fin
File vide ?
Cette fonction indique si la file f est vide. Dans le cas d'une reprsentation par liste chane, la file est vide si
la liste qui la reprsente est vide.
fonction fileVide(FILE f): BOOLEEN
dbut
fileVide := listeVide(f);
fin
Tte d'une file
Cette fonction retourne l'lment en tte de la file f. Dans le cas d'une reprsentation par liste chane, cela
revient retourner la valeur de l'lment en tte de la liste. A n'utiliser que si la file f n'est pas vide.
fonction teteFile(FILE f) : ELEMENT
variables
ELEMENT e init NIL;
dbut
si (non (fileVide(f))) alors e := teteListe(f); finsi
teteFile := e ;
fin

Entrer un lment dans une file
Cette fonction place un lment e en queue de la file f. Pour la reprsentation par liste chane, cela revient
ajouter l'lment e en queue de la liste.
fonction entrerElement(FILE f, ELEMENT e): FILE
dbut
entrerElement := ajouterQueue(f,e);
fin
Sortir un lment d'une file
Cette fonction retire l'lment en tte de la file pointe par f et stocke sa valeur dans e. Pour la
reprsentation par liste chane, cela revient rcuprer la valeur de l'lment en tte de liste avant de le
supprimer de cette dernire.
variables
dbut
si (non (fileVide(f))) alors e := teteFile(f); f := queue(f) ;finsi
sortirElement := (f,e) ;
fin

Oprations pour la modlisation par tableau circulaire
Initialiser une file
Cette fonction initialise les valeurs de la structure reprsentant la file pointe par f pour que celle-ci soit vide.
Dans le cas d'une reprsentation par tableau circulaire, on choisira de considrer la file vide lorsque f.tete =
f.fin. Arbitrairement, on choisit ici de mettre ces deux indices 0 pour initialiser une file d'attente vide.
fonction initialiserFile() : FILE
variables
FILE f ;
dbut
f.tete := 0;
f.fin := 0;
initialiserFile := f ;
fin
File vide ?
Cette fonction indique si la file f est vide. Dans le cas d'une reprsentation par tableau circulaire, la file est
vide lorsque f.tete = f.fin.
fonction fileVide(FILE f): BOOLEEN
dbut
fileVide := (f.tete = f.fin);
fin
Tte d'une file
Cette fonction retourne l'lment en tte de la file f. Dans le cas d'une reprsentation par tableau circulaire, il
suffit de retourner l'lment point par l'indice de tte dans le tableau. A n'utiliser que si la file f n'est pas
vide.
fonction teteFile(FILE f): ELEMENT
variables
ELEMENT e init NIL;
dbut
si (non fileVide(f)) alors e := (f.tab[f.tete]); finsi
teteFile := e ;
fin
Entrer un lment dans une file
Cette fonction place un lment e en queue de la file f. Pour la reprsentation par tableau circulaire,
l'lment est plac dans la case pointe par l'indice fin. Ce dernier est ensuite augment d'une unit, en
tenant compte du fait qu'il faut revenir la premire case du tableau si il a atteint la fin de celui-ci. D'o

l'utilisation de l'oprateur mod qui retourne le reste de la division entre ses deux membres. Ceci ne peut tre
excut que si le tableau n'est pas plein au moment de l'insertion.
fonction entrerElement(FILE f, ELEMENT e): FILE
dbut
si ((f.fin + 1) mod NMAX <> f.tete) alors
f.tab[res.fin] := e;
f.fin := (f.fin + 1) mod NMAX;
finsi
entrerElement := f ;
fin
On dtecte que le tableau est plein si l'indice fin est juste une case avant l'indice tete. En effet, si on ajoutait
une case, fin deviendrait gal tete, ce qui est notre configuration d'une file vide. La taille maximale de la file
est donc NMAX - 1, une case du tableau restant toujours inutilise.
Sortir un lment d'une file
Cette fonction retire l'lment en tte de la file f et stocke sa valeur dans e. Pour la reprsentation par
tableau circulaire, cela revient rcuprer la valeur de l'lment en tte de file avant de le supprimer en
augmentant l'indice tete d'une unit. Il ne faut pas oublier de ramener tete la premire case du tableau au
cas o il a atteint la fin de ce dernier.
variables
dbut
si (non(fileVide(f))) alors
e := teteFile(f);
f.tete := (f.tete + 1) mod NMAX;
finsi
sortirElement := (f, e) ;
fin

Conclusion
Ce genre de structure de donnes est trs utilise par les mcanismes d'attente. C'est le cas notamment
d'une imprimante en rseau, o les tches d'impressions arrivent alatoirement de n'importe quel ordinateur
connect. Les tches sont places dans une file d'attente, ce qui permet de les traiter selon leur ordre
d'arrive. Les remarques concernant les diffrences entre la modlisation par liste chane et la modlisation
par tableau circulaire sont les mmes que pour la structure de file. Trs peu de diffrences sont constates.
En rsum, la modlisation par liste chane sera un peu plus lente, mais plus souple quant sa taille.


Les arbres

Gnralits
Dans ce chapitre nous nous intressons aux structures de donnes arborescentes. Ces structures
dynamiques rcursives constituent un outil important qui est couramment utilis dans de nombreuses
applications : codage de Huffman, interfaces, SGBD, expressions arithmtiques, intelligence artificielle,
gnomique, etc. Nous distinguerons dans un premier temps les arbres binaires, avant dtendre et de
gnraliser cette structure, quon peut dfinir simplement comme une disposition hirarchique de nuds,
dans laquelle le nud situ au dessus de chaque fils est son pre.
Le type Arbre Binaire
Dans un arbre binaire, chaque nud a au plus 2 fils.

Nud

fils gauche fils droit = branche

feuilles =

Les feuilles sont des nuds sans fils.

Exemple : (5 + 2) (3 + 4)
* + 5 2 + 3 4 *

+ +

5 2 3 4

Dans certaines applications, seules les feuilles contiennent de linformation utile.
Oprations de base
Dclaration
ArbreBinaire Info a init ARBREVIDE ;

typedef struct t_arbre {
Info *info;
struct t_arbre *filsG, *filsD;
} *Arbre, Nud;

Arbre a = NULL;
Test de vacuit
Fonction vide (Arbre a) : Boolen
dbut
vide := a = ARBREVIDE ;
fin


int vide(Arbre a)
{
return a==NULL;
}
Accs au fils gauche
Arbre filsGauche(Arbre a)
{
Arbre res = NULL;
If ( !vide(a) ) res = a->filsG;
return res;
}
Initialisation
info(a) := info; filsG(a) :=ARBREVIDE; filsD(a) := ARBREVIDE;

Nud *nouveauNoeud(Info *info)
{
Nud *n = malloc(sizeof(Nud));
n->info = info;
n->filsG = n->filsD = NULL;
return n ;
}
Parcours prfix
procdure parcours(ArbreBinaire Info a)
dbut
si NON vide(a) alors
traiter(info(a));
parcours(filsG(a));
parcours(filsD(a));
finsi
fin
Parcours infix
dbut
parcours(filsG(a));
traiter(info(a));
parcours(filsD(a));
finsi
fin
Parcours postfix
dbut
parcours(filsG(a));
parcours(filsD(a));
traiter(info(a));
finsi
fin
Parcours par niveau
Ce type de parcours, en largeur dabord, ncessite lemploi de structures de donnes particulires, comme
des piles ou des liens vers les frres, si lon souhaite optimiser le parcours. En revanche, il est possible de le
faire facilement, en multipliant les parcours, et en ne traitant que le niveau concern chaque passage.


Destruction dun arbre
procdure detruireArbre(ArbreBinaire Info a)
dbut
dtruireArbre(filsG(a));
dtruireArbre(filsD(a));
dtruireNoeud(a);
finsi
fin
Ajout dun fils
gauche
fonction insertionG(ArbreBinaire Info a, ArbreBinaire Info n) : ArbreBinaire
dbut
si NON vide(a) filsG(a) := n;
insertionG := a;
fin
Enracinement
A partir de 2 arbres et dune valeur, on construit un nouvel arbre. Pour cela on doit crer un nouveau nud.
fonction enracinement(Info v, ArbreBinaire Info a, ArbreBinaire Info b) : ArbreBinaire
variables
ArbreBinaire Info n init ARBREVIDE ;
Dbut
Info(n) := v ;
filsG(n) := a;
filsD(n) := b;
enracinement := n;
fin

Arbre enracinement(Arbre a, Arbre b)
{
Nud *n = malloc(sizeof(Nud));
n->info = NULL;
n->filsG = a;
n->filsD = b;
return n ;
}
Feuille
fonction estFeuille(ArbreBinaire Info a):Boolen
variables
Boolen res init FAUX;
dbut
si vide(filsG(a)) ET vide(filsD(a)) alors res := VRAI; finsi
estFeuille := res;
fin
Comptage
fonction compte(ArbreBinaire Info a)
variables
entier res init 0;
dbut
res:=1+compte(filsG(a))+compte(filsD(a));
finsi
compte := res;
fin

hauteur d'un arbre
fonction hauteur(ArbreBinaire a) : entier
variables
entier res init 0 ;
dbut
si NON vide(a) alors res := max(hauteur(filsG(a), hauteur(filsD(a))) + 1 ; finsi
hauteur := res ;
fin
Prsence dun lment dans un arbre
fonction appart(Info v, ArbreBinaire a)
variables
Boolen res init FAUX ;
dbut
si v = info(a) alors res := VRAI ;
sinon res := appart(v, filsG(a)) OU| appart(v, filsD(a)) ;
finsi
finsi
apprt := res ;
fin
Suppression d'un lment dans un arbre
S'il n'y a pas d'ordre, on remplace l'lment supprim par n'importe quel lment. Par convention, on prend
le 1
ier
du fils gauche de l'lment supprim, etc. S'il y a un ordre, il faut remplacer l'lment supprim par un
lment qui vrifie cette condition d'ordre. Cette fonction supprime toutes les occurrences dun lment dans
un arbre non ordonn.
fonction supparbre (info v, ArbreBinaire a) : ArbreBinaire
variables
ArbreBinaire res = ARBREVIDE ;
dbut
si v = info(a) alors
si vide(filsG(a)) alors res := supparbre (v, filsD (a)) ;
sinon res:=enraciner(info(filsG(a)), suppdarbre(info(filsG(a)),filsG(a)), suppdarbre(v, filsD(a)));
finsi
sinon res := enraciner(info(a), suppdarbre(v,supparbre(info(filsG(a)),filsG(a)))), suppdarbre(v, filsD (a))) ;
finsi
finsi
supparbre := res ;
fin

Arbres binaires ordonns
Suppression d'un lment dans un arbre ordonn
Lorsquon supprime le sommet, il faut le remplacer par le minimum de fils droit pour respecter la condition
d'ordre. Il faut donc d'abord crire une fonction qui trouve le minimum d'un arbre.
fonction minArbre(ArbreBinaire a) : Info
variables
Info res ;
dbut
si NON vide (a) alors
si vide(filsG(a)) alors res :=info(a) ;
sinon res := minArbre(filsG(a)) ;
finsi
finsi
minArbre := res ;
fin

fonction suppordrearbre(Info v, ArbreBinaire a) : ArbreBinaire
variables
ArbreBinaire res init ARBREVIDE ;
dbut
si v = info(a) alors
si vide(filsD(a)) alors res := filsG (a) ;
sinon res := enraciner(minArbre(filsD(a)), filsG (a), suppordrearbre(minArbre(filsD(a)),filsD (a))) ;
finsi
sinonsi v < sommet res := enraciner (sommet(a), suppordrearbre(v, filsG (a)), filsD (a)) ;
sinon res := enraciner (info(a), filsG(a), suppordrearbre(v, filsD(a))) ;
finsi
finsi
suppordrearbre := res ;
fin
Insertion d'un lment dans un arbre ordonn
Le but est d'insrer une valeur la bonne place. Lalgorithme est le suivant : on compare la valeur au nud.
Si elle est infrieure, on explore le fils droit. Si elle est suprieure, on parcourt le fils gauche. On
recommence pour le fils suivant jusqu'aux feuilles.
fonction insererordonn (ArbreBinaire a, Info v) : ArbreBinaire
variables
ArbreBinaire res;
dbut
si vide(a) alors res := nouveauNoeud(v) ;
sinonsi info(a) v alors res := enraciner(info(a), insererordonn(filsG(a), v), filsD(a)) ;
sinon res := enraciner(info(a), filsG(A), insererordonn(filsD(a), v) ;
finsi
insererordonn := res ;
fin

procdure afficheArbreOrdonn(ArbreBinaire Info a)
dbut
afficheArbreOrdonn (filsG(a));
afficher(info(a));
afficheArbreOrdonn (filsD(a));
finsi
fin

Application : les arbres dictionnaires
pas seulement pour les mots

si la 1
ire
lettre du mot se trouve au sommet

fils gauche sinon fils droit

reste du mot tout le mot

Remarque : mme si lettre suivante avant m, on va dans fils gauche.

Exemple : le les moi toi blabla lulu lili

l

e m

fin u o t

s l i i o b

fin u l fin i l

fin i fin a

fin b

l

a

fin
Aprs chaque mot, il y a un caractre fin qui va dans le fils gauche de la dernire lettre du mot.
Si la premire lettre du mot est dans la racine alors le reste du mot est gauche.
Si la premire lettre du mot n'est pas dans la racine alors le mot est droite.
Il faut commencer cet arbre avec la premire lettre la plus frquente.

fonction rechercher_mot(Liste m, ArbreBinaire a) : Boolen
variables
Boolen res init FAUX ;
dbut
si NON vide (a) alors
si vide(m) alors
si info(a) = fin res := VRAI;
sinon res := FAUX ;
fsi
sinonsi tete(m) = info(a) res := rechercher_mot(suivant(m), filsG(a)) ;
sinon res := rechercher_mot(m, filsG(a)) ;
finsi
finsi
rechercher_mot := res ;
fin

fonction inserer_mot(Liste m, ArbreBinaire a) : ArbreBinaire
variables
ArbreBinaire res;
dbut
ii vide(a) alors res := construire(m) ;
sinonsi videliste(m) alors
si info(a) = fin alors res := a ;
sinon res := enraciner(fin, ARBREVIDE, a) ;
finsi
sinonsi tete(m) = info(a) alors res : enraciner(tete(m), inserer_mot(suivant(m), filsG(a)), filsD(a)) ;
sinon res := enraciner(tete(m), filsG(a), inserer_mot(m, filsD(a))) ;
finsi
inserer_mot := res ;
fin


fonction construire(Liste m) : ArbreBinaire
variables
ArbreBinaire res ;
dbut
si videliste(m) alors res := enraciner(fin, ARBREVIDE, ARBREVIDE) ;
sinon res := enraciner(tete(m), enraciner(suivant(m)), ARBREVIDE) ;
finsi
construire := res ;
fin

Parcours heuristique darbres
Un arbre est une structure particulirement adapte pour reprsenter lexploration des solutions dun
problme, dans le cas de la rsolution par essais successifs. Toutefois, lefficacit de la recherche de la
solution dpend souvent de lordre dans lequel elles ont explores. On peut alors avoir recours un autre
type de parcours des arbres, dit heuristique, qui permet dexplorer des branches la demande, et non de
manire systmatique comme le parcours en profondeur dabord.
Exemple : le jeu du taquin
C'est un jeu dont le but est de reconstituer laide de permutations une image dcoupe en morceaux et
disposs sur une grille carre. Les permutations sont uniquement possible avec lunique emplacement vide.
Comment faire pour revenir la configuration idale ?

Tout dabord il faut modliser le jeu. On utilisera alors un tableau 2 dimensions, qui contient les pices
repres par un numro ou un caractre. Une valeur servira reprsenter la case libre.
Toute action de jeu se rsume inverser les contenus de la case vide et dune de ses voisines. Ces
permutations sont au nombre de 2, 3 ou 4 en fonction de la position du trou.
Pour revenir la configuration idale, on peut tre tent de tester tous les coups possibles, et de refaire ceci
partir de chaque configuration obtenue, jusqu obtenir la solution. Le problme est quon retrouve des
tats dj connus, ce qui ne garantit pas que lon va finir par tomber sur la configuration finale. Pour viter
de retrouver des configurations dj visites (bouclage), on se propose de les mmoriser. On a pour cela un
grand choix de structures, comme les listes, ou mieux les arbres, qui sont bien adapts pour dcrire le
cheminement qui a conduit au rsultat.
Parmi les possibilits, il est intressant essayer d'abord celles qui "semblent" les meilleures. Ainsi, on ne
souhaite pas parcourir tout larbre des configurations, mais seulement dvelopper la demande certains
nuds. On introduit alors la notion d heuristique , qui est une valeur associe chaque configuration et
qui est une estimation de sa proximit de la solution. Pour ce qui est du jeu du taquin, une heuristique
efficace est par exemple la somme des distances de chaque portion dimage sa position idale. La
distance entre 2 cases est la somme des valeurs absolues des diffrences de lignes et de colonnes. Sur la
figure suivante, le trou est une distance 3 de sa position idale (1 ligne et 2 colonnes).
Enfin, il faut sassurer que la configuration de dpart bien t obtenue par mlange de limage idale,
et quon peut donc robtenir cette image, ce qui nest pas forcment possible depuis une configuration
quelconque. Ceci pourrait tre vrifi laide dune fonction de dtection de bouclage.

A B C
D E F
?
D A C
B F
G E H G H

La figure suivante montre larbre de parcours heuristique des solutions : toutes les configurations ne sont
pas dveloppes, seulement celles quon estime tre les plus favorables.

typedef unsigned char Jeu[MAXSIZE][MAXSIZE];

typedef struct t_arbre
{
Jeu jeu;
int distance;
int mt, nt;
int marque;
struct t_arbre *fils[4];
} Noeud, *Arbre;

void afficheJeu(Jeu jeu, int h, int l) ;
void initTaquin(Jeu jeu, Jeu ref, int *H, int *L, char *nf) ;
void chercherVal(unsigned char val, Jeu ref, int h, int l, int *m, int *n) ;
int valJeu(Jeu jeu, Jeu ref, int h, int l) ;
Noeud *meilleureConfig(Arbre arbreJeu) ;
int pasDansArbre(Jeu jeu, Arbre arbreJeu, int h, int l) ;
Arbre enraciner(Jeu jeu, Jeu ref, Arbre arbre, int numFils, int h, int l) ;
void jouer(Jeu ref, int h, int l, Arbre arbreJeu) ;

Arbres quilibrs (bien balancs)


Arbres n-aires
Il est relativement ais de manipuler des arbres dont les nuds comportent plus de 2 fils. Toutefois cela
devient plus complexe lorsque ce nombre peut tre quelconque.
Dans un arbre n-aire, un nud peut possder un nombre quelconque de fils. La structure la mieux adapt
la gestion dune collection dinformations tant la liste, un nud darbre n-aire pourra alors tre dcrit par sa
valeur et une liste de ses fils, qui sont eux aussi des arbres
Il est tout fait possible de reprsenter cette liste par un tableau dynamique, ou par une liste chane.
Modlisation des arbres n-aires
Arbres n-aires avec des tableaux dynamiques
typedef struct t_arbreN {
Info *info;
int nbFils;
struct t_arbreN *fils[]; // tableau
} *ArbreN, Nud;

ArbreN a = NULL;
Arbres n-aires mis en uvre avec des listes chanes
typedef struct t_arbre; // rf. avant
struct t_arbre *a;
} *Liste, Cellule; // Liste darbres
typedef struct t_arbreN {
Info *info;
Liste listeFils;
} *ArbreN, Nud; // Arbre n-aire


Les graphes
Dfinition
Un graphe orient G est reprsent par un couple (S, A) o S est un ensemble fini et A une relation binaire
sur S. Lensemble S est lensemble des sommets de G et A est lensemble des arcs de G. La figure
suivante gauche est une reprsentation graphique du graphe orient G = (S,A) avec lensemble de
sommets S = {1,2,3,4,5,6} et lensemble darcs A = {(1,2), (2,2), (2,4), (2,5), (4,1), (4,5), (5,4), (6,3)} ; les
sommets tant reprsents par des cercles et les arcs par des flches. On notera que les bouclesune
boucle tant un arc qui relie un sommet lui-mme sont ici possibles.

Dans un graphe non orient G=(S,A), lensemble des artes A nest pas constitu de couples mais de
paires de sommetsune paire tant non ordonne contrairement un couple. Par convention, on
reprsente larte entre les sommets u et v non par la notation {u,v} mais, indiffremment, par les notations
(u,v) ou (v,u). Dans un graphe non orient les boucles sont interdites et chaque arte est donc constitue de
deux sommets distincts. La figure prcdente, droite, est une reprsentation graphique du graphe non
orient G=(S,A) avec lensemble de sommets S={1,2,3,4,5,6} et lensemble darcs ={(1,2), (2,5), (5,1), (6,3)}.
Si (u,v) est un arc dun graphe orient G = (S,A), on dit que (u,v) part du sommet u et arrive au sommet v.
Si (u,v) est une arte dun graphe non orient G = (S,A), on dit que larte (u,v) est incidente aux sommets u
et v.
Dans un graphe non orient, le degr dun sommet est le nombre dartes qui lui sont incidentes. Si un
sommet est de degr 0, comme le sommet 4 de la figure droite, il est dit isol. Dans un graphe orient, le
degr sortant dun sommet est le nombre darcs qui en partent, le degr (r)entrant est le nombre darcs qui
y arrivent et le degr est la somme du degr entrant et du degr sortant.
Un chemin est la suite d'arcs qui permettent de relier un sommet i un sommet j.
Dans un graphe orient G = (S,A), un chemin de longueur k dun sommet u un sommet v est une
squence (u0,u1, ...,uk) de sommets telle que u = u0, v = uk et (ui-1,ui) A pour tout i dans {1, ...,k}. Un
chemin est lmentaire si ces sommets sont tous distincts. Dans la figure du graphe orient, le chemin
(1,2,5,4) est lmentaire et de longueur 3, mais le chemin (2,5,4,5) nest pas lmentaire. Un sous-chemin
p dun chemin p = (u0,u1, ...,uk) est une sous-squence contigu de ses sommets. Autrement dit, il existe i et
j, 0 <= i <= j <= k, tels que p = (ui,ui+1, ...,uj). On dfinit dans les graphes non orients la notion
correspondante de chane.
Un circuit est un chemin dont les extrmits concident.
Dans un graphe orient G = (S,A), un chemin (u0,u1, ...,uk) forme un circuit si u0 = uk et si le chemin contient
au moins un arc. Ce circuit est lmentaire si les sommets u1, ..., uk sont distincts. Une boucle est un circuit
de longueur 1. Dans un graphe non orient G = (S,A), une chane (u0,u1, ...,uk) forme un cycle si k >= 3 et si
u0 =uk. Ce cycle est lmentaire si les sommets u1, ..., uk sont distincts. Un graphe sans cycle est dit
acyclique.
Un graphe non orient est connexe si chaque paire de sommets est relie par une chane. Les
composantes connexes dun graphe sont les classes dquivalence de sommets induites par la relation
est accessible partir de . Le graphe non orient de la figure contient trois composantes connexes :
{1,2,5}, {3,6} et {4}.
Un graphe orient est fortement connexe si chaque sommet est accessible partir de nimporte quel autre.
Les composantes fortement connexes dun graphe sont les classes dquivalence de sommets induites
par la relation sont accessibles lun partir de lautre . Le graphe de la figure gauche contient trois
composantes connexes : {1,2,4,5}, {3} et {6}.
On dit quun graphe G = (S,A) est un sous-graphe de G = (S,A) si S S et si A A.

Les graphes pondrs / valus ont des poids : chaque arc a une valeur.
Parcours des graphes
Le parcours des graphes se rvle tre un peu plus compliqu que celui des arbres. En effet, les graphes
peuvent contenir des cycles et nous voulons viter de parcourir indfiniment ces cycles ! Pour viter cet
cueil on colorie les sommets des graphes : initialement les sommets sont tous blancs ; lorsquil est
rencontr pour la premire fois un sommet est peint en gris ; lorsque tous ses successeurs dans lordre de
parcours ont t visits, un sommet est repeint en noir.

Parcours en profondeur

fonction PP (sommet x) : ens
variables
ensemble Y init {} :
dbut
pour tout j succ(x) faire
Y := {j} PP(j) Y ;
finpour
PP := Y ;
fin

a
b
x

c

Les sommets partir de x sont tous les successeurs de x et les successeurs des successeurs de x.
Attention, cet algorithme ne fonctionne que s'il n'y a ni boucle ni cycle. Pour viter cela, il faut marquer les
lments :
fonction PP (Sommet x) : ens
variables ensemble Y init {} :
dbut
pour tout j succ(x) faire
si non marqu(j) alors
marqu(j) := VRAI ;
Y := {j} PP(j) Y ;
finsi
finpour
PP := Y ;
fin

fonction PP(Graphe G) : Graphe
variables
Tableau Couleur couleur[] ;
Sommet u ;
dbut
pour chaque sommet u de G faire couleur[u] := BLANC ; finpour
pour chaque sommet u de G faire
si couleur[u] = BLANC alors (G, couleur) := VISITER-PP(G, u, couleur) ;
finsi
finpour
PP := G ;

fin

fonction VISITER-PP(Graphe G, Sommet s, Tableau Couleur couleur[]) : (Graphe, Tableau Couleur)
variables
Sommet v ;
dbut
couleur[s] := GRIS ;
pour chaque voisin v de s faire
si couleur[v] = BLANC alors (G, couleur) := VISITER-PP(G, v, couleur) ; finsi
finpour
couleur[s] := NOIR ;
VISITER-PP := (G, couleur) ;
fin

Parcours en largeur

fonction PL(Graphe G, Sommet s) : Ensemble
variables
Sommet u, v ;
Tableau Couleur couleur[] ;
Ensemble F ;
dbut
couleur[s] := GRIS ;
pour chaque sommet u de G, u <> s, faire couleur[u] := BLANC ; finpour
F := {s} ;
tant que F <> {} faire
(u, F) := SUPPRESSION(F) ;
pour chaque voisin v de u faire
si couleur[v] = BLANC
alors couleur[v] := GRIS ;
F := INSERTION(F,v) ;
finsi
finpour
couleur[u] := NOIR ;
fintantque
PL := F ;
fin
Reprsentation des graphes
On reprsente les graphes sous forme matricielle ou sous forme de listes. Comment trouver les cycles ?
Tableau 2 dimensions :
Cest la reprsentation la plus simple et la plus volumineuse : n sommets = tableau n
1 2 3 4 5

1 0 0 1 0 0 V
1

2 0 1 0 0 0 V
2

3 0 0 0 1 0 V
3

4 0 0 0 0 1 V
4

5 1 0 1 0 0 V
5

Il faut choisir et prciser une orientation de lecture : les successeurs sont ici les lignes et les prdcesseurs
les colonnes. Si le graphe est valu, au lieu de 1 on met la valeur des arcs. Si les sommets sont valus, on

prvoit une colonne supplmentaire pour la valeur des sommets. On trouve les boucles en regardant la
diagonale du tableau.
Les matrices d'incidence aux arcs :
pour un graphe orient non valu.
j
i arcs
sommets 1 2 3 4 5 6 7
1 1 -1 1 0 0 0 0

2 0 0 0 0 0 0 V

3 0 0 -1 0 1 0 0

4 0 0 0 0 1 -1 0

5 -1 1 0 1 -1 0 0

a(i, j) = -1 si j entrant, = 1 si j sortant, = 0 sinon, = V si boucle

Le multi-pointage NULL

1

3 4 5 NULL

1 1 NULL 3
5
2 3 4 5
2 NULL
3 NULL
4 5 3 NULL
4
3 4 NULL
5 5
3 4
1
etc 5 NULL
NULL
Les ttes chanes

G 1

5 3 1

3 4

5

Les ttes contigus

1 5 3

2 2

3 4

4 5

5 3 1

Fonctions de manipulation des graphes

Graphe sans valeur
estvidegraphe graphe Bool
cregraphevide rien graphe
adjsomm graphe + sommet graphe
supsomm graphe + sommet graphe
adjarc graphe + arc graphe
suparc graphe + arc graphe
succsomm graphe + sommet sommet
predsomm graphe + sommet sommet
degint graphe + sommet entier
adjext graphe + sommet graphe
Enssucc graphe + sommet E(s) (ensemble de sommets)
Enspred graphe + sommet E(s)

Graphe avec valeur
idem sauf :
adjsomm graphe + sommet + valeur graphe
supsomm graphe + sommet + valeur graphe
adjarc graphe + arc + valeur graphe
suparc graphe + arc + valeur graphe

Les arbres sont utiliss pour traiter des conditions.

Les graphes sont utiliss pour traiter des boucles.


Application : graphe de reprsentation d'une molcule
Plus courts chemins ( origine unique)
Dans un problme de plus courts chemins, on possde en entre un graphe orient pondr G = (S,A) de
fonction de pondration w : A. Le poids du chemin p = (v0,v1, ...,vk) est la somme des poids de ses arcs :
k
w(p) = w(vi-1,vi).
i=1
Le poids (u,v) dun plus court chemin dun sommet u un sommet v est bien videmment le minimum des
poids des chemins de u v (si celui-ci est dfini, ce qui peut ne pas tre le cas si le graphe contient un
circuit de poids strictement ngatif). Un plus court chemin dun sommet u un sommet v est alors un
chemin de u v de poids (u,v).
On souhaite dans cette section trouver les plus courts chemins depuis un sommet origine s et vers nimporte
quel autre sommet. Dans la suite, [u] dsignera le prdcesseur de u dans lestimation du plus court
chemin de s u et d[u]
dsignera la longueur de ce chemin.
Algorithme de Dijkstra
Lalgorithme de Dijkstra rsout le problme de la recherche dun plus court chemin origine unique pour un
graphe orient pondr G=(S,A) dans le cas o tous les arcs ont un poids positif ou nul : (u,v)A,
w(u,v)>=0.
Lalgorithme de Dijkstra maintient jour un ensemble E des sommets de G dont le plus court chemin partir
de lorigine s est connu et calcul. chaque itration, lalgorithme choisit parmi les sommets de S \ E
cest- dire parmi les sommets dont le plus court chemin partir de lorigine nest pas connu le sommet u
dont lestimation de plus court chemin est minimale. Cet algorithme est donc glouton. Une fois un sommet u
choisi, lalgorithme met jour, si besoin est, les estimations des plus courts chemins de ses successeurs (les
sommets qui peuvent tre atteint directement partir de u).
SOURCE-UNIQUE-INITIALIZATION initialise les valeurs de [u] et de d[u] pour chaque sommet u : initialement, il
ny a pas de chemin connu de s u (si u <> s) et u est estim tre une distance infinie de s.
RELCHER(u, v, w) compare le plus court chemin de s v connu avec une nouvelle proposition (chemin
estim de s u puis arc de u v), et met les diffrentes donnes jour si besoin est.
Voici lalgorithme de Dijkstra pour le calcul des plus courts chemins.
fonction SOURCE-UNIQUE-INITIALIZATION(Graphe G, Sommet s) : (Tableau valeur, Tableau valeur)
variables
Tableau valeur d[],[] ;
Sommet v ;
dbut
pour chaque sommet v de G faire
d[v] := +;
[v] := NIL;
finpour
d[s] := 0;
SOURCE-UNIQUE-INITIALIZATION := (d, );
fin

fonction RELACHER(Sommet u, v; Poids w; Tableau valeur d[],[]) : (Tableau valeur, Tableau valeur)
dbut
si d[v] > d[u]+w(u,v) alors
d[v] := d[u]+w(u,v);
[v] := u;
finsi
RELACHER := (d, );
fin

fonction DIJKSTRA(Graphe G, Poids w, Sommet s) : Ensemble
variables
Ensemble E init {}, F ;
Sommet u, v ;
dbut

(d, ) := SOURCE-UNIQUE-INITIALIZATION(G, s);
F := S ;
tant que F <> {} faire
(u, F) := EXTRAIRE-MIN(F) ;
E := E {u} ;
pour chaque arc (u,v) de G faire
(d, ) := RELCHER(u, v, w , d, );
finpour
fintantque
DIJKSTRA := E ;
fin
Cet algorithme fournit effectivement les plus courts chemins. Lalgorithme glouton fonctionne uniquement
parce que les poids sont positifs. On montre la correction de lalgorithme par rcurrence.
Le premier sommet ajout E est s car d[s] vaut alors 0 quand toutes les autres distances estimes sont
infinies.
Supposons qu un instant donn pour chaque sommet u de E, d[u] est bien la longueur du plus court
chemin de s u. On rajoute alors un sommet v E. d[v] est alors minimale parmi les sommets de S\E.
Montrons que d[v] = (s,v).
Soit p un plus court chemin de s v Soit y le premier sommet de p nappartenant pas E. Par minimalit de
d[v] on a : d[v]<=d[y]. De plus on a d[y] = (s,y) : parce que p contient le plus court chemin de s x et donc
de s au prdcesseur z de y, parce que d[z] = (s, z) par hypothse de rcurrence, et finalement parce que
z a t relch.
Par positivit des poids, (s,y)<=(s,v). Donc d[v]<=d[y] = (s,y)<= (s,v) et d[v] = (s,v).
La figure suivante prsente un exemple dexcution de lalgorithme de Dijkstra.
Complexit
La complexit de lalgorithme dpend de la complexit de lopration EXTRAIRE-MIN. Dans le cas
(dfavorable) o on implmente lensemble F au moyen dun simple tableau, la recherche du minimum cote
chaque fois (|F|) = O(|S|). La boucle tant que sexcutant exactement |S| fois, et chaque arc tant
visit une unique fois, la complexit de lalgorithme est O(|S|
2
+|A|) = O(|S|
2
).
Exemple
La figure suivante prsente un exemple dexcution de lalgorithme de Dijkstra : lorigine est le sommet le
plus gauche ; dans chaque graphe, les sommets noirs sont lments de E, le sommet gris est celui qui va
tre rajout E et les arcs en pointills sont ceux utiliss pour les estimations des plus courts chemins, les
longueurs de ces chemins tant indiques dans les sommets.

Algorithme de Bellman-Ford
Lalgorithme de Bellman-Ford rsout le problme des plus courts chemins avec origine unique dans le cas
gnral o le poids des arcs peut tre ngatif. Appel sur un graphe G = (S,A), lalgorithme de Bellman-Ford
renvoie un boolen indiquant si le graphe contient ou non un circuit de poids strictement ngatif accessible
partir de lorigine. Voici lAlgorithme de Bellman-Ford pour le calcul des plus courts chemins.

fonction BELLMAN-FORD(Graphe G, Poids w, Sommet s) : Boolen
variables
Sommet u, v ;
Boolen res init VRAI
dbut
(d, ) := SOURCE-UNIQUE-INITIALIZATION(G, s);
pour i depuis 1 jusque |S|-1 faire
pour chaque arc (u,v) A faire
(d, ) := RELACHER(u, v, w , d, );
finpour
finpour
pour chaque arc (u,v) A faire
si d[v] > d[u]+w(u,v) alors res := FAUX ; (+ arrt boucle) finsi
finpour
BELLMAN-FORD := res;
fin
Correction
La correction de lalgorithme de Bellman-Ford peut se montrer par rcurrence sur le nombre darcs des plus
courts chemins : la fin de la ime itration de la premire boucle, les plus courts chemins contenant au plus
i arcs sont connus, la condition que le graphe ne contienne aucun circuit de poids strictement ngatif. |S|-1
itrations suffisent car un plus court chemin est lmentaire (sans perte de gnralit) et contient donc au
plus |S|-1 arcs.
Vu ce qui prcde, lalgorithme renvoie VRAI sil ny a pas de circuit de poids strictement ngatif. Montrons
quil renvoie FAUX sinon. Pour sen convaincre, prenons un circuit c de sommets u0,u1, ...,up-1,upu0. Si
lalgorithme renvoie VRAI, alors pour tout i [1, p], on a d(ui) <= d(ui-1+w(ui-1,ui). Par sommation on obtient :
) ( 0 ) ( ) ( ) ( ) ( ) ( ) ( ) , ( ) ( ) (
0
1 1 1
1
1
1
1
c w c w u d u d c w u d u d u u w u d u d
p
p
i
i
p
i
i
p
i
i i
p
i
i
p
i
i
+ + +

= = =
=
Donc, si lalgorithme renvoie VRAI le graphe ne contient pas de circuit de poids strictement ngatif.
Complexit
Cet algorithme est en (|S|.|A|) car linitialisation et la vrification de la non-existence dun circuit de poids
strictement ngatif sont en (|S|) et (|A|) respectivement, et car la boucle pour sexcute exactement
(|S|-1) fois et que chaque itration visite chaque arc exactement une fois ce qui nous cote (|S|.|A|).
Exemple
La figure qui suit est un exemple dexcution de lalgorithme de Bellman-Ford : lorigine est le sommet le plus
gauche ; dans chaque graphe les arcs en pointills sont ceux utiliss pour les estimations des plus courts
chemins, les longueurs de ces chemins tant indiques dans les sommets. Les arcs sont considrs dans
lordre lexicographique : (u,v), (u,x), (u,y), (v,u), (x,v), (x,y), (y,v), (z,u) et (z,x).

Poly3 ASD

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Poly3 ASD

Încărcat de

Drepturi de autor:

Formate disponibile

ALGORITHMIQUE

Dpartement d'Informatique de l'Universit Louis Pasteur,

S-ar putea să vă placă și