In formatique de base Cours 3 ème

Th_Info_B - 1M. BENJELLOUN 2004-2005

Informatique de baseCours 3ème

Mohammed BENJELLOUN

Service d’Informatique

Faculté Polytechnique de Mons

[email protected]

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


• 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.


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).

. . .

. . .


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


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)


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


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])

…

}

}


#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


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;

}


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];


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)


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--


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--


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++


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--


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++; } } }


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


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.


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,


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.


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


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.


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)


Les tours de Hanoï

Récursivité simple


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.


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


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


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 */

};


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


@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


@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


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


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


…….. 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


void main(void){

int *var1 ;

*var1 = 5; Il faut réserver la mémoire

int *var1

int i=5; 5

var1 = &i 5


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));


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


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;


debut

NULL

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






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);}


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;


Alfred

pClaire Denis

NULL

prec

Alfred

p

debut




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


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(..);…


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


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


Liberation

Si

typedef struct Cellule{ char *nom; struct Cellule * suiv;}CEL;

malloc

malloc

void liberation (CEL *L){…

free(nom); free(tmp);

…}

Pour chaque Cellule


TRI

Claire Denis

NULL

Alfred

Claire Denis

NULL

Alfred

1

2

3


Claire Denis

NULL

Alfred

1

2

3

TRI

Alfred

1

Claire

3

Denis

NULL

2


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.


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


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


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


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


Push(5)

debut

5

Push(9)9

Push(3)

3

NULL

debutdebutPush(7)

7

debut

Push procédure


#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;

}


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


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


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


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;}


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.


Exemple


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


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’’


3 joueurs

4 joueurs


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


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


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[])


. . .

. . .

NULLdebut

?


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


debut

fin

NULL

debutprev = NULL;

debutnext = fin;

finprev = debut;

NULL

finnext = NULL;

data prev next


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


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


NULL

NULL

tmp


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


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


VB

R J M

VB

R

J

M B VB

R J

M

G


V B G

G

G

J J

J

M

la boule la plus légère

J V B G

Exemple 2


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


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.


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


Cd2 Cd3Cd1 Cd4

Art1

Art2

Art3

Art1

Art2

Art3

Art1

Art2

Art3

Art1

Art2

Art3

In formatique de base Cours 3 ème

Documents

Transcript of In formatique de base Cours 3 ème