View
24
Download
1
Category
Preview:
DESCRIPTION
In formatique de base Cours 3 ème. Mohammed BENJELLOUN Service d’Informatique Faculté Polytechnique de Mons Mohammed . Benjelloun @fpms.ac.be 2004-2005. Le but. L’informatique ne se limite pas à : la programmation et l’utilisation des outils informatiques,. - PowerPoint PPT Presentation
Citation preview
Th_Info_B - 1M. BENJELLOUN 2004-2005
Informatique de baseCours 3ème
Mohammed BENJELLOUN
Service d’Informatique
Faculté Polytechnique de Mons
Mohammed.Benjelloun@fpms.ac.be
2004-2005
Th_Info_B - 2M. BENJELLOUN 2004-2005
L’informatique ne se limite pas à : la programmation et l’utilisation des outils informatiques,
Le but
Se faire une idée sur :
La complexité, taille des données et place mémoire, modularité,
temps d’exécution, portabilité …
Connaissance des principaux types d’algorithmes et de structures
de données afin d’éviter de « réinventer la roue »
mais la meilleure manière de résoudre le problème : nécessite réflexion mathématique, structuration et organisation le bon algorithme, la bonne structure de données
Th_Info_B - 3M. BENJELLOUN 2004-2005
• Les notions fondamentales de structures de données et de leur utilisation
• Comment les implanter à bon escient (en C)
• Comprendre l'importance de la spécification rigoureuse des structures
• La complexité des algorithmes
• Les principes de mise en oeuvre de ces structures.
Th_Info_B - 4M. BENJELLOUN 2004-2005
Les structures de données présentées ici sont:
- Tableaux (arrays en anglais),tab[0] tab[1] tab[2] tab[3]
- Listes chaînées (linked lists en anglais),
- les piles (stacks), - les files (queues),
- Arbres binaires (binary trees).
. . .
. . .
Th_Info_B - 5M. BENJELLOUN 2004-2005
Tableaux
Un tableau est une collection de variables de même type, appelées éléments
Type Nom_Tableau[dim];
int tab[4]; déclare un tableau de 4 valeurs entières
tab[0] tab[1] tab[2] tab[3]
int int int int5 10 7 16
Tableaux et structuresstruct Date {
int jour;int mois;int an;
} hier, demain;struct Date D_Nais[7];
11
22
19801980
55
33
19711971
1313
44
20022002
1414
1010
19951995
99
11
19551955
33
1212
19691969
2828
22
20032003
// D_Nais[3].an est le champ an de la 4è position // du tableau de structure Date; 1995
Th_Info_B - 6M. BENJELLOUN 2004-2005
Mesure intrinsèque de l’efficacité d’un algorithme, indépendante de l’environnement d’exécution.
On peut la considérer comme une fonction exprimant le nombre d’opérations nécessaires ou d’instructions exécutées en fonction de la taille des données à traiter. Ordre d’une fonction O(f)
Complexité
Evaluer l’ordre d’une fonction ‘’supprime’’ tout ce qui devient négligeable à l’infini.
Exemple : n(n-1) O(n2); n3+n2+8n+9 O(n3)
Th_Info_B - 7M. BENJELLOUN 2004-2005
Exemple : Le Tri à bulle void TriaBulles(int x[], int N){
int i, perm=1, tmp; // variables locales à TriaBulles
while (perm==1) {perm =0;for (i=0;i<N-1;i++) {
if(x[i]>x[i+1]) {tmp = x[i];x[i] = x[i+1];x[i+1] = tmp;perm = 1;
}}
}}
La mesure de complexité est le nombre de fois où le corps de la boucle interne est exécuté et on évalue la complexité dans le pire des cas, c’est à dire : le tableau ne se révèle trié qu’à la dernière étape.
permuter
Th_Info_B - 8M. BENJELLOUN 2004-2005
1ère étape : la boucle interne est exécutée n-1 fois,
2 ème étape : la boucle interne est exécutée n-2 fois,
… complexité i i[1, n-1]
n-1 + n-2 + …. 2 + 1 = n(n-1)/2 O(n2)
6 26 4 26 4 8 26 4 8 12 2 ……
0
2
1
6
2
4
3
8
4
12
5
13
6
14
tab[j] < tab[j+1]
jtab[j]
66 44 88 1212 1313 1414 221414 1313 1212 88 66 44 22
while (perm==1) {
for (i=0;i<N-1;i++) {
if(x[i]>x[i+1])
…
}
}
Th_Info_B - 9M. BENJELLOUN 2004-2005
#define …..
#define MAX 30
struct Article{ char nom[Max];
int prix;
};
void main(void) {
struct Article Tab_article[MAX];
int i, dim = 10;
for (i = 0; i < dim; i++) {
printf("Entrez le nom"); scanf("%s", Tab_article[i].nom);
printf(" \n Entrez le prix "); scanf("%d", &Tab_article[i].prix);
}
…
}
nom1prix1
nom2prix2
nom3prix3
nom4prix4
…
Article1 Article2 Article3
Th_Info_B - 10M. BENJELLOUN 2004-2005
do{ p=0; for (i=0;i < NE-1;i++) {
a = strcmp (tab[i].nom,tab[i+1].nom);if (a>0) { permute(&tab[i],&tab[i+1]); p=1;}
}}while (p==1);
do { p=0; for (i=0;i < NE-1;i++) {
a = strcmp (tab[i].nom,tab[i+1].nom);if (a==0) { q=1; if (tab[i].prix>tab[i+1].prix) { permute(&tab[i],&tab[i+1]); p=1; }}
}} while (p==1);
O(n2)
O(n2)
struct Article{
char nom[Max];
int prix;
};
struct Article tab[20]; void permute(int *x,int *y){
int tmp;
tmp= *x;
*x = *y;
*y = tmp;
}
Th_Info_B - 11M. BENJELLOUN 2004-2005
i=-1;permut=1;while(i< NE-1 && permut){
permut=0;for(j=…..)
if( (strcmp(tab[j].nom,tab[j+1].nom)>0) || (((strcmp(tab[j].nom,tab[j+1].nom)==0)
&& (tab[j].prix>tab[j+1].prix))) ) {permut=1;tempo=tab[j];tab[j]=tab[j+1];tab[j+1]=tempo;
}i++;
}
O(n2)
struct Article{
char nom[Max];
int prix;
};
struct Article tab[20];
Th_Info_B - 12M. BENJELLOUN 2004-2005
Drapeau tricolore (Dijkstra)
Soit un tableau Tab de N cases contenant NB boules bleues (B), Nb boules blanches (b) et NR boules rouges (R).
R B b b R B R b B R b B B R b b
On souhaite classer ces boules de sorte que
B B B B B b b b b b b R R R R R
Solution
Pas nécessaire d'utiliser un algorithme de tri car il y a beaucoup de valeurs égales qui nécessitent des comparaisons inutiles.
Trier les boules par valeurs croissantes en prenant, par exemple, B = 1, b = 2 et R = 3.
La complexité : O(N2)
Th_Info_B - 13M. BENJELLOUN 2004-2005
Algorithme itératif Hypothèse :
Les k premiers éléments sont classés, le tableau se présente comme suit:
BB BB BB bb bb bb RR RR RR RR bb BB BB RR bb bb
0 i j kboules à classer : Clas
0 <= i <= j <=k <= N-1
Si en k la boule est R pas de permutation. k = k+1 et Clas=Clas-1
BB BB BB bb bb bb RR RR RR bb bb BB BB RR bb bb
Si en k la boule est b
0 i j k
permutation de k et j. j++, k++ et Clas--
Th_Info_B - 14M. BENJELLOUN 2004-2005
BB BB BB bb bb bb BB RR RR RR bb BB BB RR bb bb
0 i j kk++
BB BB BB BB bb bb bb RR RR RR bb BB BB RR bb bb
0 ii++ jj++ k
Si en k la boule est B
BB BB BB bb bb bb RR RR RR BB bb BB BB RR bb bb
0 i j k
permutation de k et j puis i et j. i++,j++, k++ et Clas--
Th_Info_B - 15M. BENJELLOUN 2004-2005
La complexité de l'algorithme est obtenue en comptant le nombre de permutations qui est égal à 0 x NR + 1 x Nb + 2 x NB.
Complexité ??
Si en k la boule est R pas de permutation. k = k+1 et Clas=Clas-1
BB BB BB bb bb bb RR RR RR bb bb BB BB RR bb bb
Si en k la boule est b
0 i j k
permutation de k et j. j++, k++ et Clas--
permutation de k et j puis i et j. i++,j++, k++ et Clas--Si en k la boule est B
BB BB BB bb bb bb BB RR RR RR bb BB BB RR bb bb
0 i j kk++
Th_Info_B - 16M. BENJELLOUN 2004-2005
La complexité de l'algorithme est obtenue en comptant le nombre de permutations qui est égal à 0 x NR + 1 x Nb + 2 x NB.
En moyenne, on a NB = Nb = NR = N/3, et la complexité moyenne est d'ordre N
L'algorithme itératif se révèle donc bien meilleur que l'algorithme immédiat.
la boule est R pas de permutation. k = k+1 et Clas=Clas-1
la boule est b permutation de k et j. j++, k++ et Clas--
la boule est B permutation de k et j puis i et j. i++,j++, k++ et Clas--
Th_Info_B - 17M. BENJELLOUN 2004-2005
void Drapeau( int Tab[], int N){ int i=0,j=0,k;
for (k=0; k<N; k++){ if (Tab[k] == Bleu){ permute(Tab[k], Tab[j]); permute(Tab[j], Tab[i]); i++; j++; } else{ if (Tab[k] == blanc){ permute(Tab[k], Tab[j]); j++; } } }
Th_Info_B - 18M. BENJELLOUN 2004-2005
Nous constatons qu'avec les boules bleues, il est nécessaire de réaliser deux permutations. Comment en faire moins en sachant que toute permutation débute à partir de la zone à classer?
Est-il possible de l'améliorer?
BB BB BB bb bb bb RR RR RR BB bb BB BB RR bb bb
Th_Info_B - 19M. BENJELLOUN 2004-2005
Plaçons la zone à classer "au milieu" du tableau comme représenté ci-dessous.
BB BB BB bb bb bb BB RR bb BB bb BB BB RR RR RR
0 i jkboules à classer : Clas
0 <= i <= k <=j <= N-1
j = Indice de la dernière boule non classée.
Th_Info_B - 20M. BENJELLOUN 2004-2005
BB BB BB bb bb bb BB RR bb BB bb BB BB RR RR RR
0 i jkboules à classer : Clas
Si en k la boule est R pérmutation (k, j-1), j-- et Clas--
Si en k la boule est b pas de pérmutation k++ et Clas--
Si en k la boule est B pérmutation (k, i), k++, i++ et Clas--
Le nombre de permutations est égal à 1 x NR + 0 x Nb + 1 x NB.
Le second algorithme paraît meilleur que le premier.
et la complexité moyenne est d'ordre 2N/3.
Complexité ? En moyenne, on a NB = Nb = NR = N/3,
Th_Info_B - 21M. BENJELLOUN 2004-2005
En effet, 1er : 0 x NR + 1 x Nb + 2 x NB 2d : 1 x NR + 0 x Nb + 1 x NB
Toutefois il peut parfois être moins bon
2d - bon 1er ?? nbOP2 > nbOP1
2d > 1er NR + NB > Nb + 2 x NB NR > Nb + NB
NR + Nb + NB = N NR > N - NR
NR > N/2
Donc, si le nombre de boules rouges est supérieur au nombre total de
boules / 2, le premier algorithme est meilleur.
Th_Info_B - 22M. BENJELLOUN 2004-2005
Une procédure P est dite récursive si son exécution peut provoquer un ou plusieurs appels (dits récursifs) à P. On distingue:- la récursivité simple (appel direct à P)- la récursivité croisée (appel à la procédure Q qui appelle P).
Programmation Récursive
int fact (int n )
{
if ( n < 0) return –1; //code d'erreur
else if ( n == 0 ) return 1; // 0! = 1
else
return n*fact( n-1 ); // n! = n*(n-1)!
}
Récursivité simple
Th_Info_B - 23M. BENJELLOUN 2004-2005
Factorielle
int fact (int n )
{
if ( n < 0) return –1; //code d'erreur
else if ( n == 0 ) return 1; // 0! = 1
else
return n*fact( n-1 ); // n! = n*(n-1)!
}
void CalculFact( int num){
int fact = 1;int temp;
while ( num >0 ){
Push( num )num--;
}
while ( Pop(&temp) ){
fact *= temp;}
}
Les piles sont commodes pour dé-récursiver un problème.
Th_Info_B - 24M. BENJELLOUN 2004-2005
Fractales
Flocons de von Koch
Le flocon d'ordre 0 est un triangle équilatéral. Le flocon d'ordre 1 est ce même triangle dont les côtés sont découpés
en trois et sur lequel s'appuie un autre triangle équilatéral au milieu.Le flocon d'ordre n+1 consiste à prendre le flocon d'ordre n en
appliquant la même opération sur chacun de ses côtés.
Le résultat ressemble à un flocon de neige idéalisé.
Programmation fct(sin, cos)
Th_Info_B - 25M. BENJELLOUN 2004-2005
Les tours de Hanoï
Récursivité simple
Th_Info_B - 26M. BENJELLOUN 2004-2005
Pour déplacer N anneaux d'une colonne de départ à une colonne d'arrivée en utilisant une colonne intermédiaire, on suppose que l'on peut déplacer N – 1 anneaux du départ à l'intermédiaire, déplacer l'anneau restant du départ à l'arrivée et déplacer les N – 1 anneaux de l'intermédiaire à l'arrivée.
Th_Info_B - 27M. BENJELLOUN 2004-2005
void Hanoi( int N, int x, int y){ … if (N==1) Deplacer(1, x, y); else{ Hanoi( N-1, x, 3-x-y); // on a posé x=0, y=1, z=2 donc x+y+z=3
Deplacer(N, x, y); Hanoi( N-1, 3-x-y, y); }}
L'ordre de complexité est donné par le nombre de déplacements d'anneaux.A chaque appel récursif, on appelle deux fois la procédure dans laquelle on réalise un déplacement.Le nombre de déplacements est donc égal à 2N – 1 et la complexité est d'ordre 2N
Th_Info_B - 28M. BENJELLOUN 2004-2005
struct Date{
int jour;int mois;int an;
} hier, demain;struct Date D_Nais[7];
11
22
19801980
55
33
19711971
1313
44
20022002
1414
1010
19951995
99
11
19551955
33
1212
19691969
2828
22
20032003
Avantages : Facilité de création et de manipulation (accès à un élément, …) Inconvénients : place mémoire, difficilement extensible, insertion n’est
possible que par décalage de tous les éléments suivants.
Tableaux et structures
// D_Nais[3].an est le champ an de la 4è position // du tableau de structure Date; 1995
Th_Info_B - 29M. BENJELLOUN 2004-2005
Listes Chaînées
Les listes sont des structures de données dynamiques, linéaires. Elles sont composées de cellules chaînées les unes aux autres par pointeurs.
Une liste simplement chaînée : une cellule est un enregistrement qui peut être déclarée comme suit:
struct Node {int data; /* les informations */struct Node *suiv; /* le lien */
};
struct Node {int data; /* les informations */struct Node *suiv; /* le lien */
};
Une liste doublement chaînée
struct Node {int data; /* les informations */struct Node *suiv; /* lien vers le suivant */struct Node *prec; /* lien vers le précédent */
};
struct Node {int data; /* les informations */struct Node *suiv; /* lien vers le suivant */struct Node *prec; /* lien vers le précédent */
};
Th_Info_B - 30M. BENJELLOUN 2004-2005
Une cellule étant une structure qui contient un élément à stocker et un pointeur sur la prochaine cellule de la liste. struct Cellule{ ELEMENT Data; // une structure définie préalablement struct Cellule *suiv; // pointeur sur le prochain maillon}; Modéliser une liste chaînée consiste à allouer dynamiquement les cellules chaque fois que cela est nécessaire.
Listes Chaînées
TêteElm1 Elm2 Elm3 Elm4
Liste simplement chaînée
Th_Info_B - 31M. BENJELLOUN 2004-2005
@4000
Elem1 @ 0700
Elem2 @ 0900
Elem3 @ 2170
Elem4 NULL
@4000 @0700 @0900
@2170
Tête_List
Autres modélisations
@4000
Elem1 @ 0700
Elem2 @ 0900
Elem3 @ 2170
Elem4 NULL
@4000 @0700 @0900
@2170
Tête_List@2170 Fin_List
Th_Info_B - 32M. BENJELLOUN 2004-2005
@4000
Elem1 @ 0700
Elem2 @ 0900
Elem3 @ 2170
Elem4 NULL
@4000 @0700 @0900
@2170
Tête_List@2170 Fin_List
@0700 Courant_List
@4000
Elem1 @ 0700
Elem2 @ 0900
Elem3 @ 2170
Elem4 @4000
@4000 @0700 @0900
@2170
Tête_List
Liste circulaire
Th_Info_B - 33M. BENJELLOUN 2004-2005
Initialiser les valeurs de la structure représentant la liste pointée par Debut pour que celle-ci soit vide. Une liste est vide lorsque Tête_List (Fin_List) pointe sur Vide.
Les différentes opérations et fonctions
typedef struct Cellule{ ELEMENT Data; // une structure struct Cellule * next; // pointeur sur la prochaine cellule}CEL;
CEL *debut; debut = (CEL *) malloc( sizeof(CEL));debut=NULL ;
typedef : mot réservé, crée de nouveaux noms de types de données
Ex : typedef char * STRING; fait de STRING un synonyme de "char * " Portée : comme les variables.
Initialiser une liste
Th_Info_B - 34M. BENJELLOUN 2004-2005
Types de base en C
Type Signification Codage en mémoire
char Caractère unique 1 octet
int Nombre entier 2 ou 4 octets
float Nombre réel simple précision
4 octets4 octets
double Nombre réel double précision
8 octets8 octets
Th_Info_B - 35M. BENJELLOUN 2004-2005
…….. 88 3535 ……..
Adr i =
Mémoire12FF80 12FF84 =Adr i+1
int i;i=8;
l'adresse de l'élément i est &i
&i= 12FF80
4 octets
int
…….. 12FF84 …….. 3535 ……..
pointeur
12FF8412FF04
int *p; *p est le contenu pointé par p 35 p est l’adressse 12FF84
Le pointeur prend comme valeurs des adresses de données en mémoire
Th_Info_B - 36M. BENJELLOUN 2004-2005
void main(void){
int *var1 ;
*var1 = 5; Il faut réserver la mémoire
int *var1
int i=5; 5
var1 = &i 5
Th_Info_B - 37M. BENJELLOUN 2004-2005
var1 = (int *) malloc (sizeof(int));
void main(void){int *var1 ;
var1 = (int *) malloc (sizeof(int)); *var1 = 5;
…
} + free
int *var1
CEL *debut; (CEL *) malloc( sizeof(CEL));
debut = (CEL *) malloc( sizeof(CEL));
Th_Info_B - 38M. BENJELLOUN 2004-2005
CEL * new_node(int value){ CEL * nouv; nouv = (CEL *)malloc(sizeof(CEL)); nouvData value(s); nouvsuiv = NULL; return nouv;}
Allouer et assigner une Cellule
Cette fonction réserve l'espace mémoire nécessaire pour une nouvelle Cellule dans la liste, assigne les données, et retourne un pointeur sur cette Cellule.
nouv=new CEL;
typedef struct Cellule{ Type Data; struct Cellule * suiv;}CEL;
NULLnouv
Th_Info_B - 39M. BENJELLOUN 2004-2005
Si
typedef struct Cellule{ char nom[30]; struct Cellule * suiv;}CEL;
Nouvelle cellule dans une liste chaînée vide
CEL *debut;debut = (CEL *) malloc (sizeof(CEL));
strcpy ( debutname, “Denis”);debutsuiv = NULL;
CEL *debut;debut = (CEL *) malloc (sizeof(CEL));
strcpy ( debutname, “Denis”);debutsuiv = NULL;
debut
Le début de la liste est indiqué par un pointeur indépendant (debut) et la fin par NULL
Denis\0
NULL
typedef struct Cellule{ Type Data; struct Cellule * suiv;}CEL;
Th_Info_B - 40M. BENJELLOUN 2004-2005
debut
NULL
CEL *prec;prec = (CEL *) malloc (sizeof(CEL));
strcpy ( precname, “Claire”);precsuiv = debut;debut = prec;
CEL *prec;prec = (CEL *) malloc (sizeof(CEL));
strcpy ( precname, “Claire”);precsuiv = debut;debut = prec;
prec
Claire Denis
debut
Ajouter une nouvelle cellule en tête de liste
Th_Info_B - 41M. BENJELLOUN 2004-2005
CEL *prec;prec = (CEL *) malloc (sizeof(CEL));
strcpy ( precname, “Claire”);precsuiv = debut;debut = prec;
CEL *prec;prec = (CEL *) malloc (sizeof(CEL));
strcpy ( precname, “Claire”);precsuiv = debut;debut = prec;
Claire
prec
Ajouter une nouvelle cellule en tête de liste
debut
Denis
NULL
CEL *insere_en_tete(char nom[] , CEL *deb ){
CEL*prec; prec = (CEL *) malloc(sizeof(CEL)); // créer une cellule
if (prec!=NULL) { strcpy ( precname, nom); // assignation de nom
precsuiv=deb; // assignation de suivant : chaîner avec la première cellule de la liste
deb=prec; // chaînage : faire pointer la tête de liste vers la nouvelle cellule.
} return (deb);}
Th_Info_B - 42M. BENJELLOUN 2004-2005
Insérer une nouvelle cellule après la cellule prec
Claire
debut
Denis
NULL
prec
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);psuiv = precsuiv;precsuiv = p;
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);psuiv = precsuiv;precsuiv = p;
Alfred
pClaire Denis
NULL
prec
Alfred
p
debut
Th_Info_B - 43M. BENJELLOUN 2004-2005
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);psuiv = precsuiv;precsuiv = p;
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);psuiv = precsuiv;precsuiv = p;
Que fait ce code ?
Claire
debut
Denis
NULL
prec
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);precsuiv = p;psuiv = precsuiv;
CEL *p;p = (CEL *) malloc (sizeof(CEL));strcpy ( pname, “Alfred”);precsuiv = p;psuiv = precsuiv;
Alfred
p
Th_Info_B - 44M. BENJELLOUN 2004-2005
void Affichage (CEL *debut){ while (debut != NULL) {
printf (“%s\n”, debutname);debut = debutsuiv;
}}
void Affichage (CEL *debut){ while (debut != NULL) {
printf (“%s\n”, debutname);debut = debutsuiv;
}}
Claire Denis
NULL
Alfred
debut
Que pensez-vous de la fonction Affichage?
CEL *p;..p=Saisie(..);Affichage(..);Affichage(..);
p=Ajout(..);Affichage(..);…
Th_Info_B - 45M. BENJELLOUN 2004-2005
Parcourir une liste
void parcours (CEL *debut){
CEL *p;p = debut;while ( p != NULL) {
printf (“%s\n”, pname);p = psuiv;
}}
void parcours (CEL *debut){
CEL *p;p = debut;while ( p != NULL) {
printf (“%s\n”, pname);p = psuiv;
}}
Claire Denis
NULL
Alfred
debut
debut est un pointeur sur la cellule qui contient le premier élément de la
liste
Liste identifier par l'adresse de sa première cellule
Th_Info_B - 46M. BENJELLOUN 2004-2005
void liberation(CEL *L){if (L) {
CEL *tmp = Lsuiv;free(L);liberation(tmp);
}}
void liberation (CEL *L){
CEL *tmp;while ( L != NULL) {
tmp = L;L=Lsuiv;free(tmp);
}}
Liberation
Claire Denis
NULL
Alfred
tmp
Th_Info_B - 47M. BENJELLOUN 2004-2005
Liberation
Si
typedef struct Cellule{ char *nom; struct Cellule * suiv;}CEL;
malloc
malloc
void liberation (CEL *L){…
free(nom); free(tmp);
…}
Pour chaque Cellule
Th_Info_B - 48M. BENJELLOUN 2004-2005
TRI
Claire Denis
NULL
Alfred
Claire Denis
NULL
Alfred
1
2
3
Th_Info_B - 49M. BENJELLOUN 2004-2005
Claire Denis
NULL
Alfred
1
2
3
TRI
Alfred
1
Claire
3
Denis
NULL
2
Th_Info_B - 50M. BENJELLOUN 2004-2005
Supprimer une cellule Libérer une cellule Rechercher une cellule Ajouter en queue de liste Retirer la tête de liste …
Autres fonctions
En résumé, une liste chaînée par pointeurs permet une insertion et une suppression rapide des éléments. Cependant, contrairement au tableau, une liste chaînée interdit un accès direct aux éléments (mis à part la tête et la queue). Si l’ordre d’insertion et de suppression des éléments dans la liste importe, deux structures de données sont particulièrement adaptées :
la pile et la file.
Th_Info_B - 51M. BENJELLOUN 2004-2005
Une pile est une liste qui respecte la régle “dernier arrivé, premier sorti”. C’est une structure de données pour laquelle l’ajout et la suppression d’un élément ne sont autorisés qu’à une seule extrémité, appelée sommet de la pile.
Quant on ajoute un élément, celui-ci devient le sommet de la pile. Quant on retire un élément de la pile, on retire toujours le sommet. Pour résumer, le dernier entré/premier sorti liste LIFO (Last In, First Out). Les piles sont souvent commodes pour dé-récursiver un problème.
Modéliser une pile consiste à utiliser une liste chaînée en n'utilisant que les opérations ajouterTete et retirerTete. Dans ce cas, on s'aperçoit que le dernier élément entré est toujours le premier élément sorti.
PILE [stack, lifo]
Modélisation
Th_Info_B - 52M. BENJELLOUN 2004-2005
fonction BOOLEEN empilerElement(CEL * p, ELEMENT Nouv){ return (ajouterTete(p, Nouv) );}
Empiler un élément sur une pile
Cette fonction empile l'élément Nouv au sommet de la pile pointée par p. Cela revient à ajouter l'élément Nouv en tête de la liste. VRAI est retournée si l'élément a bien été ajouté.
TêteElm1 Elm2 Elm3Elm1 Elm2 Elm3Nouv
Th_Info_B - 53M. BENJELLOUN 2004-2005
Cette fonction dépile l'élément au sommet de la pile pointée par p et stocke sa valeur à l'adresse e. Cela revient à récupérer la valeur de l'élément en tête de liste avant de le supprimer de cette dernière. VRAI est retournée si la pile n'est pas déjà vide.
fonction BOOLEEN depilerElement(PILE * p, ELEMENT * e) { if ( ! pileVide(*p)) { *e = sommet(*p); return ( retirerTete(p) ) ; } else{ return FAUX; } }
Il ne faut pas oublier de libérer la mémoire à chaque retrait du sommet de la pile.
Dépiler un élément d'une pile
Tête Elm1 Elm2 Elm3Elm1 Elm2 Elm3NouvElm1 Elm2 Elm3
Th_Info_B - 54M. BENJELLOUN 2004-2005
LIFOLast-In-First-Out
•Le dernier élément ajouté dans la liste, est le premier à en sortir.
•Opérations: Créer la pile, Ajouter un élément (Push),
Effacer un élément (Pop), Eliminer la pile .
Exemple
Th_Info_B - 55M. BENJELLOUN 2004-2005
Push(5)
debut
5
Push(9)9
Push(3)
3
NULL
debutdebutPush(7)
7
debut
Push procédure
Th_Info_B - 56M. BENJELLOUN 2004-2005
#define MALLOC( struct_type, times) ( struct_type *) malloc( times *sizeof( struct_type ));
struct NODE *pLifoStart;
int Push( int nombre) {
NODE *pNew;pNew = MALLOC( NODE, 1);if( pNew == NULL ) return 0;
pNew->nombre = nombre;pNew->next = pLifoStart;pLifoStart = pNew;return 1;
}
Th_Info_B - 57M. BENJELLOUN 2004-2005
Top
5
Top
9
Top
3
Top
7
NULL
Top
Pop(7)
Top
Pop(3)
Top
Pop(9)
Pop(5)
Underflow risksi la pile est vide !!!
POP procédure
Th_Info_B - 58M. BENJELLOUN 2004-2005
Simulation de la factorielle
4! = 4*3!
4
5! = 5*4!
5
1! = 1*0!
1
2! = 2*1!
2
3! = 3*2!
3
5! = ??
0! = 1
0
Th_Info_B - 59M. BENJELLOUN 2004-2005
Simulation de la factorielle
4! = 4*3!
4
5! = 5*4!
5
1! = 1*0!
1
2! = 2*1!
2
3! = 3*2!
3
5! = ??
0! = 1
0
0! = 1
5! = 5 *24 = 120
1! = 1 *1 = 1
2! = 2 *1 = 2
4! = 4 *6 = 24
3! = 3 *2 = 6 LIFO
Th_Info_B - 60M. BENJELLOUN 2004-2005
int Pop( int *pNombre ) // == supprimer début de liste{
NODE *pTemp;
récupérer l'élément en tête de liste avant de le supprimer
free( pTemp );
return 1;}
Th_Info_B - 61M. BENJELLOUN 2004-2005
void CalculFact( int num){
int fact = 1;int temp;
while ( num >0 ){
Push( num )num--;
}
while ( Pop(&temp) ){
fact *= temp;}
printf( "La factorielle est %i\n\n", fact);}
Les piles sont commodes pour dé-récursiver un problème.
Th_Info_B - 62M. BENJELLOUN 2004-2005
Exemple
Th_Info_B - 63M. BENJELLOUN 2004-2005
Une file d'attente est une structure de données pour laquelle l’ajout et la suppression d’un élément ne sont autorisés qu’aux seules extrémités, appelées la tête et la queue de la file. Les éléments sont ajoutés en queue de file et sont retirés en tête de file. Pour résumer, le premier entré/ le premier sorti liste FIFO (First In, First Out).
FILE D'ATTENTE , queue [queue, FiFo]
TêteElm0 Elm1 Elm2 Elm3
Queue
Elm0 Elm1 Elm2
Exemple : Imprimante en réseau
Elm0 Elm1 Elm2Nouv
Th_Info_B - 64M. BENJELLOUN 2004-2005
Jeu de 52 cartes (4 couleurs et 13 puissances).
Le jeu est d'abord mélangé pour ensuite être coupé afin de constituer deux tas de 26 cartes
Simulation du déroulement d'une partie du jeu de cartes ‘’Bataille’’
Th_Info_B - 65M. BENJELLOUN 2004-2005
Th_Info_B - 66M. BENJELLOUN 2004-2005
Th_Info_B - 67M. BENJELLOUN 2004-2005
Th_Info_B - 68M. BENJELLOUN 2004-2005
3 joueurs
4 joueurs
Th_Info_B - 69M. BENJELLOUN 2004-2005
TP3
Créer une liste simplement chaînée dont chaque cellule contient les champs suivants : { int data; /* les informations */ struct Node *next; /* le lien : pointeur sur la cellule suivante */}
Le programme doit gérer en boucle le menu de choix suivant :
1- Créer une liste avec insertion en tête de liste (avec affichage)2- Sauver la liste 3- Insérer dans la liste (avec affichage)4- Nettoyer la mémoire et sortir
Th_Info_B - 70M. BENJELLOUN 2004-2005
1 : Crée une liste en insérant 2n, puis 2n-2, puis 2n-4, … et enfin 0 qui sera en tête de la liste. (Liste : 0,2,4,6,8,10, …2n.)
2 : Sauvegarde la liste dans le fichier Liste1
3 : Insère dans la liste –1, puis 1, puis 3, … et en fin 2n-1.
(Liste finale : -1,0,1,2,3,4,5,6,7,8,9,…2n)
2’ : Sauvegarde la nouvelle liste dans le fichier Liste2
4 : Libère la mémoire avant de quitter le programme.
Push(6)
debut
6
Push(4)4
Push(2)
2
NULL
debutdebutPush(0)
0
debut
Th_Info_B - 71M. BENJELLOUN 2004-2005
liste * new_node (int x)
liste *insere_en_tete(?? )
liste *insere_en_place(?? )
void parcours (liste *lis)
void liberation (liste *lis)
void sauvegarde( liste *lis, char nom_fich[])
Th_Info_B - 72M. BENJELLOUN 2004-2005
. . .
. . .
NULLdebut
?
Th_Info_B - 73M. BENJELLOUN 2004-2005
Listes doublement chaînées
struct Node {int data; // les informations
struct Node *prev; // lien vers le précédent struct Node *next; // lien vers le suivant
};
struct Node {int data; // les informations
struct Node *prev; // lien vers le précédent struct Node *next; // lien vers le suivant
};
data prev next
typedef struct Node Cel;
Cel *debut, *fin, *act;
int dim = sizeof(Cel);
debut = (Cel *) malloc(dim);fin = (Cel *) malloc(dim);
debut
fin
Th_Info_B - 74M. BENJELLOUN 2004-2005
debut
fin
NULL
debutprev = NULL;
debutnext = fin;
finprev = debut;
NULL
finnext = NULL;
data prev next
Th_Info_B - 75M. BENJELLOUN 2004-2005
debut
NULL
act
debut
NULL
fin
NULL
Insérer un élément en fin de liste
finnext = act;
actprev = fin;
NULL
actnext = NULL;
fin
fin = act;
data prev next1
2
3
4
1
23
4
Th_Info_B - 76M. BENJELLOUN 2004-2005
NULL
Insérer un élément devant act
Cel *tmp;tmp = (Cel *) malloc(dim);
tmp->prev = act->prev ;
act->prev->next = tmp;
tmp->next = act;
act->prev = tmp;
tmp
act
data prev next
1
2
3
4
1
23
4
Th_Info_B - 77M. BENJELLOUN 2004-2005
NULL
NULL
tmp
Th_Info_B - 78M. BENJELLOUN 2004-2005
Liste doublement chaînée
Liste dont les éléments ont un élément suivant et un élément précédent.Il n’y a pas de tête de liste, ni de fin de liste, la chaîne est fermée.
A B Cliste
Une liste avec un seul élément
Aliste
Th_Info_B - 79M. BENJELLOUN 2004-2005
Exemple 1
Le boulier à quatre :
VB
char *couleur_Bil; // couleur de la bille exp : vert bouteille float carct[max] ; //max = 3 = maximum des caractéristiques (masse, poids, …)
fonction Saisie:
VB
R
fonction Ajout:
VB
R J VB
R J M
Th_Info_B - 80M. BENJELLOUN 2004-2005
VB
R J M
VB
R
J
M B VB
R J
M
G
Th_Info_B - 81M. BENJELLOUN 2004-2005
V B G
G
G
J J
J
M
la boule la plus légère
J V B G
Exemple 2
Th_Info_B - 82M. BENJELLOUN 2004-2005
LabDB SPRL Facture No. 00025, avenue SGBD7000 FPMs Mons, le 15.10.2002
Client Nom : BENJELLOUNPrénom : MohammedAdresse : Serv. Info, 15Code_postal : 7000 Localité : Mons
No. Article
Libellé Prix unitaire
Quantité Prix
233 Analyse 1000 € 1 1000 €
025 MCD 700 € 2 1400 €
142 MLD 1000 € 1 1000 €
Montant total de la facture : 3400 €
Passer
1,N 1,1CLIENT
No_ClientNomPrénomAdresseCode_postalLocalité
Commande
No_FactureDate
Porter
1,N
0,N
Article
No_ArticleLibelléPrix_Unitaire
Quantité
Programmation d'un logiciel de Gestion de Commandes
Exemple 3
Th_Info_B - 83M. BENJELLOUN 2004-2005
Simplification:
ARTICLE : struct Article{ char nom[lmax]; int prix, quantite;};
But : créer un fichier du genre: 7 //nbre d‘articlesart1 5 10art2 5 15art3 20 11art4 10 12art5 10 13art6 20 14art9 2 19
Les articles ont un nom unique, un prix et une quantité positive ou nulle en stock.
Th_Info_B - 84M. BENJELLOUN 2004-2005
Commande
Une facture concernant une commande pour un client peut contenir un ou plusieurs articles.Les commandes ont un numéro unique de référence, un nom de client et une liste d'articles avec quantité.Elles seront stockées dans une structure de liste doublement chaînée.
typedef struct Cellule P_Cell; struct Cellule{
char nom[lmax];int quantite;P_Cell *next;
}; struct Commande{ char nom_client[lmax];
int numero;int montant;P_Cell *liste_articles;struct Commande *next;struct Commande *prec;
};
Exemple du fichier commandes : cli1 1 10art1 20
cli2 2 113994art2 41art3 20
ben 3 50art5 50
Th_Info_B - 85M. BENJELLOUN 2004-2005
Cd2 Cd3Cd1 Cd4
Art1
Art2
Art3
Art1
Art2
Art3
Art1
Art2
Art3
Art1
Art2
Art3
Recommended