PROGRAMMATION AVANCEE ET STRUCTURE DE

DONNEES 2

Projet Fin d’etude

GESTION DES PILES, FILES ET LISTES CHAINEES

Réalisé par :
EL HOUSSNI Abir

OULEDLACHHEB Safae

Encadré par:

EL KARFI Ikram & RIDA Nouha

Classe: 2AP7

Annee Scolaire: 2019/2020

1
 REMERCIEMENT

Ce modeste travail témoigne de notre passage à

l’Ecole Marocaine des Sciences de L’Ingénierie, cet honorable et
prestigieux établissement qui a contribué avec autant d’efficience que
d’énergie à doter ses élèves d’une formation de qualité.
Au terme de la réalisation de notre projet, on voudrait exprimer notre
gratitude et nos remerciements à Madame EL KARFI Ikram,
Professeur de la matière « programmation avancée et structure de
donnée 2», ainsi que Madame RIDA Nouha, Professeur de la matière
« programmation avancée et structure de donnée2 (TP) », pour
leursconseils et pertinentes orientations ainsi que leurs directives
considérables.

2
 SOMMAIRE :

Introduction générale:

Chapitre I : Gestion d’une file d’attente d’un musée

1. Introduction du chapitre
2. Objectif du projet
3. Analyse des questions et proposition
4. Compilation

Chapitre II : Liste circulaire sentinelle

1. Introduction du chapitre
2. Objectif du projet
3. Analyse des questions et proposition
4. Compilation

Chapitre III : Conversion décimal en binaire a l’aide d’une pile

1. Introduction du chapitre
2. Objectif du projet
3. Analyse des questions et proposition
4. Compilation

Langage et logiciel utilisé

Conclusion générale

Bibliographie

Annexes

3
 INTRODUCTION GENERALE :

Dans le cadre de notre formation à l’École marocaine des sciences de

l’ingénieur, l’établissement cherche à évoluer les compétences et le
savoir-faire de ses étudiants par divers moyens tels que des stages,
projets en classe et des projets de fin d’année.

Pour cela, on a réalisé un projet qui a comme thème «gestion des

piles, files et listes circulaires» afin de concrétiser nos acquis durant
l’année. Ce projet consiste a gerer une file d’attente d’un musee, une
liste chainee circulaire et convertir le decimal en binaire a l’aide
d’une pile a l’aide du logiciel DEV C ++ .

Au cours de ce rapport, nous allons présenter et détailler nos trois

sujets. Ceux-ci ont pour but de décrire les représentations des
structures de base utilisées en informatique telles que les files, les
piles et les listes chainées.

4
Chapitre I : Gestion d’une file d’attente d’un musée
1. Introduction du chapitre
2. Objectif du projet
3. Analyse des questions et proposition
4. Compilation

5
 Chapitre I : Gestion d’une file d’attente d’un musée

1. Introduction du chapitre:
On s’interesse dans ce chapitre a représenté une
file d’attente devant un musée par la structure d’une
file simple (à un seul pointeur).
Un individu dans la file est représenté par un numéro
(entier), si un nouvel individu aperçoit dans la file un
ami alors il se joint à lui pour attendre. Deux amis
seront alors deux entiers identiques.

2. Objectif du projet :
L’objectif de ce projet est de programmer un programme qui
pourra gerer une file d’attente d’un musee. Pour ce faire, nous
allons proposez une structure de données permettant de gérer
une telle file. Puis ecrire une fonction Ajouter permettant
d’ajouter un individu à la file , une fonction Supprimer
permettant de supprimer la tête de cette file et enfin une
fonction pour afficher ses éléments .

6
3. Analyse des questions et proposition :

a. Proposez une structure de données permettant de

gérer une file d’attente d’un musee  :

Cette structure contient un numero qui est de nature int

et une occurrence qui est aussi de nature int

7
 b. Écrire une fonction Ajouter permettant d’ajouter
un individu à la file  :

Si on parle d’un nouvel individu, on l’ajoute et

l’occurrence devient 1.
Si cette induvidu a un ami dans la file, donc, on
incremente l’occurrence.
Cette fonction retourne la file.

8
 c. Écrire une fonction Supprimer permettant de
supprimer la tête de la file (la fonction retourne la
file moins l’élément supprimé)

Cette fonction permet de supprimer la tete de la file.

Elle retourne la file moins l’element supprime.

9
 d. Écrire une fonction récursive permettant
d’afficher les éléments de la file dans leur ordre
d’arrivée  :

Cette fonction permet d’afficher les elements de la file dans

leur ordre d’arrivee.

10
 e. Tester les différentes fonctions dans la main  :

La fonction main permet de tester les 3 fonctions.

Ce menu est fait en creant un choix qui permet de choisir
la fonction voulu.

11
12
 4. Compilation :

Ceci montre que le programme est juste.

a.console :

13
Le choix de l’utilisateur :
b. ajouter un individu a la file :

c.supprimer la tete de la file :

d.afficher les elements de la file :

14
Chapitre II : Gestion d’une Liste circulaire sentinelle
1. Introduction du chapitre
2. Objectif du projet
3. Analyse des questions et proposition
4. Compilation

15
 Chapitre II : Gestion d’une Liste circulaire sentinelle
1. Introduction du chapitre:

Dans ce chapitre, on s’intéresse à la structure de donnée Liste

simplement chaînée circulaire avec sentinelle. La seule
différence avec une liste simplement chaînée circulaire est la
présence d’une cellule supplémentaire en tête de la liste
appelée la sentinelle.
Cette liste chainee a une fonction supplémentaire adPremiere
de type pointeur sur cellule et la structure cellule a deux
données membres: valeur et un pointeur qui pointe sur la
cellule suivante.

2.objectif du projet :

16
 Le but de ce projet est de realiser un programme qui
permetterai de gerer une liste circulaire sentinelle. Pour
cela, nous allons :

1.Ecrire la fonction adPremiere qui crée la liste et insère la sentinelle à

la liste.
2. Ecrire la fonction ajouterEnTete qui insère l’élément passé en
paramètre en tête de liste.
3. Ecrire la fonction ajouterEnQueue qui insère l’élément passé
en paramètre en queue de liste.
4. Ecrire une autre fonction tailleListe qui retoune le nombre des
cellules dans liste (la sentinelle n’est pas inclus).

5. Ecrire la fonction afficher qui affiche les valeurs des cellules

de la liste.

3.analyse des questions et proposition :

17
 a. Ecrire la fonction adPremiere qui crée la liste et
insère la sentinelle à la liste  :

On a d’abord créer une sctructure d’une liste simplement

chainee.
Puis on a créer une liste sentinelle et on a inserer la sentinelle.

18
 b. Ecrire la fonction ajouterEnTete qui insère
l’élément passé en paramètre en tête de liste.

On declare la nouvelle sentinelle lsentinelle pour en

ajouter une valeur x en tete de la liste. Puis on retourne
cette lsentinelle.

c. Ecrire la fonction ajouterEnQueue qui insère

l’élément passé en paramètre en queue de liste.

19
On declare encore une fois lsentinelle, puis on ajoute
une valeur en queue et on retourne apres cette
lsentinelle.

d.Ecrire une autre fonction tailleListe qui retoune

le nombre des cellules dans liste (la sentinelle
n’est pas inclus).

20
La fonction taille_Liste prend comme par parametre une liste
k et retourne sa taille en l’incrementant.

e. Ecrire la fonction afficher qui affiche les valeurs des

cellules de la liste.

Cette fonction affiche la liste

21
 f. Tester les différentes fonctions dans la main  :

La fonction main permet de tester les fonctions.

Ce menu est fait en creant un choix qui permet de choisir
la fonction voulu.

22
23
 4.Compilation :

Ceci montre que notre programme est correct

a.Console : (main)

24
b. créer la liste :

c.ajouter en tete de la liste :

25
 d.ajouter en queue de la liste :

f. Retourner la taille :

g. Afficher la liste :

26
Chapitre III: Gestion de conversion décimal en binaire à l’aide
d’une pile
1.Introduction du chapitre
2.Objectif du projet
3.Analyse des questions et proposition
4.Compilation

27
Chapitre III: Gestion de conversion décimal en binaire à l’aide
d’une pile

1. Introduction du chapitre :
Pour passer du décimal au binaire, on effectue des
divisions successives du nombre à convertir sur 2 jusqu’à
obtenir un quotient nul. Puis on constitue le nombre
binaire correspondant en lisant la suite des restes (0 et 1)
de bas en haut com l’indique l’exemple ci-contre : (34)2
=(100010)10

2. Objectif du projet :

28
 L’objectif de ce problème est d’écrire une application en
langage C permettant une conversion du décimal vers le
binaire en utilisant une pile d’entiers .
Le principe est d’empiler les restes successifs de la division du
nombre décimal sur 2, ainsi, le dernier reste se sera le sommet
de la pile.

3.analyse des questions et proposition :

a.Définir la structure d’une pile d’entiers  :

On a declarer une structure de pile

b. Écrire la fonction permettant d’empiler un

entier dans la pile  :

29
On a ajouter un entier dans la pile

c.Écrire une fonction qui reçoit comme paramètre un

nombre entier décimal n (>0), et qui retourne la pile
des restes des divisions successives de ce nombre par 2 

30
 d.. Écrire une fonction qui affiche le contenu de la
pile  :

e. Tester les différentes fonctions dans la main  :

La fonction main permet de tester les fonctions.

Ce menu est fait en creant un choix qui permet de choisir
la fonction voulu.

31
4.Compilation :

32
On constate que le projet est executable.
a. Console :

b. Entrer le nbre voulu conertir :

Exemple : 60
33
Langage et logiciel utilisé

34
 Les langages de programmation permettent de décrire
d'une part les structures des données qui seront
manipulées par l'appareil informatique, et d'autre part
d'indiquer comment sont effectuées les manipulations,
selon quels algorithmes. Ils servent de moyens de
communication par lesquels le programmeur
communique avec l'ordinateur, mais aussi avec d'autres
programmeurs ; les programmes étant d'ordinaire écrits,
lus, compris et modifiés par une équipe de
programmeurs.il est mis en œuvre par un traducteur
automatique : compilateur ou interprète. Un compilateur
est un programme informatique qui transforme dans un
premier temps un code source écrit dans un langage de
programmation donné en un code cible qui pourra être
directement exécuté par un ordinateur, à savoir un
programme en langage machine ou en code
intermédiaire, tandis que l’interprète réalise cette
traduction  à la volée .
 Le logiciel Dev-C++ est un environnement de
développement intégré permettant de programmer en
C/C++. Il utilise la version MinGW du
compilateur GCC (venu du monde du logiciel libre) et
permet d'exporter ses projets sous fichiers .dev.

35
Le compilateur Dev-C++ est assez complet. Il comprend
entre autre un "répoitre de classes", un "répertoire de
fonctions incluses", et un débogueur qui permet de
surveiller l'état des variables pendant l'exécution du
programme. L'avantage de Dev-c++, c'est qu'il est
multiplateforme. Il permet de générer des exécutables
fonctionnels sous la majorité des plateformes. L'outil de
développement Dev-c++ peut être très pratique. Il est
important de savoir s'en servir efficacement, c'est
pourquoi dans cette section sont disponible des tutoriaux
pour savoir l'utiliser correctement.

ANNEXE :
36
 Chapitre I : Gestion d’une file d’attente d’un musée
#include <stdio.h>
#include <stdlib.h>
typedef struct musee{
int numero;
int occurrence;
struct musee *suivant;
}musee, *file;
file Ajouter_indiv(int numero,file f)
{
file f1,f2=f;
f1=(file)malloc(sizeof(musee));

while(f2!=NULL)
{

if (f2->numero==numero){

f2->occurrence=f2->occurrence+1;
return f;

37
 }
f2=f2->suivant;

f1->numero=numero;
f1->occurrence=1;
f1->suivant=f;
return f1;

}
file Supprimer_tete(file f) {
if(f==NULL)
return NULL;
if(f->suivant==NULL)
{
free(f);
return NULL;
}
file f1=f ;
file f2;

38
 while (f1->suivant->suivant!=NULL) {
f1=f1->suivant;
}
f2=f1->suivant;
f1->suivant=NULL;
free(f2);
return f;
}

void Afficher_ordre(file f)
{

while(f!=NULL)
{

printf("| %d | %d | ->",f->numero,f->occurrence);
f=f->suivant;
}

printf("NULL\n");

39
}

int main(){
file f=NULL;
int x,n;
f=Ajouter_indiv(4785,f);
f=Ajouter_indiv(4229,f);
f=Ajouter_indiv(2546,f);
f=Ajouter_indiv(7425,f);
f=Ajouter_indiv(3254,f);
f=Ajouter_indiv(7425,f);
f=Ajouter_indiv(1524,f);
printf("entrez le numero de l'individu:");
scanf("%d",&x);
fflush(stdin);
if(f->numero==x){
f->occurrence++;
f=Ajouter_indiv(x,f); }
else
f=Ajouter_indiv(x,f);
40
fflush(stdin);
do{
printf("Menu:\n");
printf("------------------------------------\n");
printf("Pour quitter: 0 \n");
printf("Pour ajouter un element :1 \n");
printf("Pour supprimer :2 \n");
printf("Pour afficher :3 \n");
printf("------------------------------------\n");
fflush(stdin);
printf("Quel est votre choix:");
scanf("%d",&n);
switch(n){
case 1: Ajouter_indiv(x,f);
printf("la file est:\n");
Afficher_ordre(f);
fflush(stdin);

break;
case 2:Supprimer_tete(f);
41
printf("la file apres la supression de la tete : \n ");
f=Supprimer_tete(f);
Afficher_ordre(f);
fflush(stdin); break;
case 3:Afficher_ordre(f); break; }
fflush(stdin);
}while(n!=0);
return 0; }

Chapitre II : Gestion d’une Liste circulaire sentinelle

#include<stdio.h>
42
#include<stdlib.h>
typedef struct cellule {
int valeur;
struct cellule *suivant;
}cellule, *liste;

liste ad_premier(){
liste Sentinelle ;
Sentinelle=(liste)malloc(sizeof(cellule));
Sentinelle->suivant=Sentinelle;
return Sentinelle ;
}

liste ajout_En_Tete(int x,liste sentinelle){

liste lsentinelle;
lsentinelle=(liste)malloc(sizeof(cellule));
sentinelle->valeur=x;
liste l=sentinelle;
while(l->suivant!=sentinelle){
l=l->suivant;}
l->suivant=lsentinelle;
43
lsentinelle->suivant=sentinelle;
return lsentinelle;
}

liste ajout_En_Queue(int x,liste sentinelle){

liste lsentinelle,l;
lsentinelle=(liste)malloc(sizeof(cellule));
l=sentinelle->suivant;
sentinelle->valeur=x;
sentinelle->suivant=lsentinelle;
lsentinelle->suivant=l;
return lsentinelle;
}

int taille_Liste(liste k){

liste k1;
int taille=0;
if(k!=NULL){
k1=k->suivant;
44
}
while(k1!=k){
taille++;
k1=k1->suivant;
}
return taille;
}

void afficher(liste l){

if(l!=NULL){
liste l1=l->suivant;
do{
printf("%d \t",l1->valeur);
l1=l1->suivant;
}while(l1!=l);
printf("\n");
}
}

int main (){

45
liste l=NULL;
int x,n,a;
do{
printf("Menu:\n");
printf("------------------------------------\n");
printf("Pour quitter: 0 \n");
printf("pour creer sentinelle :1 \n");
printf("Pour ajouter en tete :2 \n");
printf("Pour ajouter en queue:3 \n");
printf("Pour retourner la taille:4 \n");
printf("Pour afficher :5 \n");
printf("------------------------------------\n");
fflush(stdin);
printf("Quel est votre choix:");
scanf("%d",&n);
switch(n){
case 1: l=ad_premier();break;
case 2: {
printf("entrer le numero a ajouter en tete");
scanf("%d",&x);
l= ajout_En_Tete(x,l);
46
printf("la liste est:\n");
afficher(l);
fflush(stdin);
break;}
case 3: {printf("entrer le numero a ajouter en queue");
scanf("%d",&x);
l=ajout_En_Queue(x,l);
printf("la liste est : \n ");
afficher(l);
fflush(stdin);
break;}
case 4: {
a=taille_Liste(l);
printf("la taille de la liste est : %d \n",a);
break;}
case 5: afficher(l);

break;
}
47
}while(n!=0);
return 0;}

Chapitre III: Gestion de conversion décimal en binaire à l’aide

d’une pile

#include <stdio.h>
#include <stdlib.h>

48
#include<string.h>
typedef struct cellule{
int valeur;
struct cellule *precedent;
}cellule, *pile;

pile empiler(int v, pile p){

pile p1=(pile)malloc(sizeof(cellule));
p1->valeur=v;
p1->precedent=p;

return p1;
}

void AffPile(pile p){

while(p!=NULL){
printf("%d",p->valeur);
p=p->precedent;
}

49
}

pile conversion (int val){

pile p=NULL;
int x;
if(val == 1){
p=empiler(1,p);
return p;

}
else{

x=val;
do{

p=empiler(x%2,p);

x=x/2;

}while(x!=0);

}
50
 return p;
}

main(){
pile p= NULL;
int x;

do{

printf("\t\t\t||entrez le nombre que vous voulez

convertir en binaire||\n\n \t\t\t\t\t ||Il doit etre >0||\n\n");
scanf("%d",&x);
if(x<=0)
printf("erreur d'entree\n\n");

}while(x<=0);
printf("\t\t*Le nombre (%d)base:10 correspond a (",x);
p=conversion(x);
AffPile( p);
printf(")base:2 apres la conversion*");}

51
 CONCLUSION GENERALE :

Ce projet est le fruit de notre travail tout au long de l’année

scolaire. Nous avons essayé de préparer ce rapport avec les
connaissances acquises lors de nos études universitaires des
piles, files et listes circulaires chainnées.

52
 BIBLIOGRAPHIE :

http://www.apt-dev.com/gestion_des_impressions.html
RAPPORT PFA

53
54