UNIVERSITÉ HASSAN 1er

FACULTE DES SCIENCES ET TECHNIQUES

SETTAT

Module : Structure de donnée AU : 2021/2022

Corrigé Travaux Dirigés 3 : Pile & File

Exercice 1
Une pile est une structure de données telle que : - l’ajout d’un élément se fait au sommet de la
pile, - la suppression d’un élément se fait également au sommet de la pile
Ecrire les fonctions suivantes :
• InitialiserPile (pile *p) qui initialise une liste vide
• Empiler(pile *p) qui permet d’ajouter un élément en tête de la pile
• CreerPile(pile); ajouter des entiers (Tableau) au contenus des nœuds de la pile
• Depiler(pile *p) qui enlève un élément en tête de la pile
• Affiche(pile *p) le contenu de la pile
• Max(pile *p) qui retourne la valeur maximale.
• NbElement(pile *p) qui retourne le nombre d’éléments.
• Séparer les pairs et les impairs dans deux piles différentes P2 (pairs) et P3 (impairs) et
retourner la pile initiale (P=P3+P2).
• Créer un menu qui permet de faire appel à chacune de ces fonctions

--------------------------------------------------Corrigé Ex1-------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
typedef struct noeud
{
int val;
struct noeud *suiv;
}noeud;

typedef struct Pile pile;

//structure de controle
struct Pile
{
noeud *premier;
};

////////////////////////////////////////////////////////////
int estvide(pile *p)
{
if(!p)
return 1;
else return 0;

}
 ///////////////////////////////////////

void Initialiser(pile *p)

{
p->premier = NULL;
}

////////////////////////////////////////
void empiler(pile *p,int x)
{
noeud *nouv=malloc(sizeof(*nouv));
nouv->val=x;
nouv->suiv=NULL;

if(p==NULL)
p->premier = nouv;
else
{
nouv->suiv = p->premier;
p->premier = nouv;
}

}
//////////////////////////////////////////////////////////////
void depiler(pile *p)
{
noeud *tmp=p->premier;
if(p==NULL)
{printf("Pile vide");}

p->premier=tmp->suiv;
free(tmp);

}
////////////////////////////////////////////////////////////// :
int longeur(pile *p)
{ int i=0;

if(p==NULL)
return 0;

while( p->premier!=NULL)
{
p->premier=p->premier->suiv;
i++;
}

return i;
}

//////////////////////////////////////////////////////////////////
void affiche(pile *p)
{ if(p==NULL)
 {printf("ERREUR\n");
exit(1);
}

noeud *tmp=p->premier;

while(tmp!=NULL)
{
printf("VALEUR = %d \n",tmp->val);
tmp=tmp->suiv;

}
}

//////////////////////// ////////////////////////////////////////
void separer(pile *p, pile *p4, pile *p6 ){

while (p->premier!=NULL) {
if (((p->premier->val) % 2) == 0)
{
empiler(p4, p->premier->val);
depiler(p);
}
else
{
empiler(p6, p->premier->val);
depiler(p);
}
}
while (p4->premier!=NULL) {
empiler(p, p4->premier->val);
depiler(p4);
}

while (p6->premier != NULL) {

empiler(p, p6->premier->val);
depiler(p6);
}

///////////////////////////////////////////////////////////////////////////
int MaxPile (pile *P){
noeud *courant=P->premier;

int max =courant->val;

while (courant != NULL)

{
if ((courant->val) > max)
{
max =courant->val;
 }
courant = courant->suiv; }
return max ;
}

//////////////////////////////////////////////////////////////////////////////
void creePile(pile *p, int n)
{
int i;
for(i=1; i<=n; i++){
empiler (p, i); }
}
////////////////////////////////////////////////////////////////////////////
int main()
{ int rep,x,test;
pile p;
pile p4;
pile p6;
Initialiser(&p);
Initialiser(&p4);
Initialiser(&p6);

/*
do{
printf("VALEUR = \n");
scanf("%d",&x);
empiler(&p,x);
printf("continuez ?\n");
scanf("%d",&rep);

}while(rep!=0);
*/

creePile(&p, 5);
affiche(&p);
separer(&p, &p4, &p6);
printf("APRES separation\n");
affiche(&p);
printf("Max = %d \n",MaxPile(&p));
printf("LONGUEUR = %d \n",longeur(&p));

return 0;
}

Exercice 2 :
Une file est une structure de données telle que : - l’ajout d’un élément se fait au queue de la
file, - la suppression d’un élément se fait au sommet de la file.
typedef struct Element Element;
struct Element
{
int nombre;
Element *suivant;
 };

typedef struct File File;

struct File
{
Element *premier;
};

Créer les fonctions suivantes :

1. Initialiserfile (file *q) qui initialise une liste vide
2. Enfiler(file *q) qui permet d’ajouter un élément dans la file
3. Defiler(file *q) qui enlève un élément de la file
4. Inserer(File *q, int X) qui insère un entier X dans la file F, tout en gardant
croissant des éléments de F.
5. NombreElement(file *q) qui retourne le nombre d’élément de la file
6. RenvoiePremier (file *q) qui renvoie le premier élément
7. Donner la valeur minimale de la file F
8. Créer un menu qui permet de faire appel à chacune de ces fonctions

File avec priorité

On veut créer une file des taches avec priorité, tel que chaque tâche est décrite par son nom et
numéro de priorité (0,1,2…10). 0 est une faible priorité et 10 est une très forte priorité.

Ecrire un programme qui ajoute une tache dans une file de tache en prenant en considération
la priorité.

NB : Une file d’attente avec priorité est une collection d’éléments dans laquelle l’insertion
ne se fait pas toujours à la queue. Tout nouvel élément est inséré, dans la file, selon sa
priorité. Le retrait se fait toujours du début.
Dans une file avec priorité, un élément prioritaire prendra la tête de la file même s’il arrive
le dernier.

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

typedef struct Element Element;

struct Element
{
int nombre;
Element *suivant;
};

typedef struct File File;

struct File
{
Element *premier;
};
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
void initialiser(File *file)
{
file->premier = NULL;

//////////////////////////////////////////////////////////////////////////////////////////////////
void enfiler(File *file, int nvNombre)
{
Element *nouveau = malloc(sizeof(*nouveau));
if (file == NULL || nouveau == NULL)
{
exit(EXIT_FAILURE);
}

nouveau->nombre = nvNombre;
nouveau->suivant = NULL;

if (file->premier != NULL) /* La file n'est pas vide */

{
/* On se positionne à la fin de la file */
Element *elementActuel = file->premier;
while (elementActuel->suivant != NULL)
{
elementActuel = elementActuel->suivant;
}
elementActuel->suivant = nouveau;
}
else /* La file est vide, notre élément est le premier */
{
file->premier = nouveau;
}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////
int defiler(File *file)
{
if (file == NULL)
{
exit(EXIT_FAILURE);
}
int nombreDefile = 0;

/* On vérifie s'il y a quelque chose à défiler */

if (file->premier != NULL)
{
Element *elementDefile = file->premier;
 nombreDefile = elementDefile->nombre;
file->premier = elementDefile->suivant;
free(elementDefile);
}

return nombreDefile;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void afficherFile(File *file)
{
if (file == NULL)
{
exit(EXIT_FAILURE);
}

Element *element = file->premier;

while (element != NULL)

{
printf("%d ", element->nombre);
element = element->suivant;
}

printf("\n");
}
///////////////////////////////////////////////////////////////////////////////////////////////////
int size (File *q){
int cpt =0;
struct Element *courant;

courant=q->premier;
if(courant==NULL) printf("la file est vide \n");
else{
while(courant!=NULL){
cpt++;
courant=courant->suivant;
}}
return cpt;}
////////////////////////////////////////////////

int getMin (File *Q) {

int min ;
Element *courant=Q->premier;
min = courant->nombre;
while(courant !=NULL)
{if(courant->nombre < min)
{
min = courant->nombre;
}
courant=courant->suivant;

}
return min;
}
//////////////////////////////////////////
void insererFile(File * f, int x){
File *f1 = malloc(sizeof(*f1));
f1->premier=NULL;
bool reponse=true ;

while (f->premier!=NULL)
{
if ( ( (f->premier->nombre) > x) && reponse )
{

enfiler(f1, x);
enfiler(f1, f->premier->nombre);
defiler(f);
reponse=false ;
}
else
{

enfiler(f1, f->premier->nombre);
defiler(f);
}
}
while (f1->premier!=NULL)
{

enfiler(f, f1->premier->nombre);
defiler(f1);
}

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int renvoiePremier(File *q){
if(q->premier==NULL){
printf("la file est vide \n");
return -1;
}
else return q->premier->nombre;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
File maFile ;
initialiser(&maFile );
int sizee,min ,choix ,val, elt, nb;

do{
printf("\n ***** GESTION MA FILE *****");
printf("\n 1. Enfiler");
printf("\n 2. Defiler ");
printf("\n 3. Afficher la file ");
printf("\n 4. Taille la file ");
printf("\n 5. Renvoyer le premier element");
printf("\n 6. Min ");
printf("\n 7. Inserer un entier ");
printf("\n 8. Quitter ");
printf("\n Saisissez votre choix ? ");
scanf("%d", &choix);
switch(choix){
case 1: printf("\n Enter la valeur à inserer dans la file :");
scanf("%d", &val);
enfiler(&maFile, val); break;
case 2: defiler(&maFile); break;
case 3: afficherFile(&maFile); break;
case 4: sizee=size (&maFile); printf("\nnombre des elements de la file: %d \n",sizee); break;
case 5: elt =renvoiePremier(&maFile); printf("\n %d :\n",elt); break;
case 6: min =getMin(&maFile); printf("\n min : %d \n",min); break;
case 7: printf("\n entier a inserer :\n"); scanf("%d", &nb);insererFile(&maFile,nb); break;
//insere 3 dans la liste :1->2 4

}
}
while(choix != 8);
getch();
return 0;
}
-----------------------------------------------file a priorité----------------------------------------
#include <stdio.h>
#include <stdlib.h>

typedef struct Element Element;

struct Element
{
char data[50];
int priorite;
Element *suivant;
};

typedef struct File File;

struct File
{
Element *premier;
};
///////////////////////////////////////////////////////////////
void intialise(File *f)
{
f->premier=NULL;
}
////////////////////////////////////////////////////////////////
char *RetourSommet(File* f) {
return f->premier->data;
}

///////////////////////////////////////////////////////////////////
void defiler(File* f) {
Element* temp = f->premier;
f->premier = temp->suivant;
free(temp);
}

/////////////////////////////////////////////////////////////////
void enfiler(File* f, char tache [], int p) {
Element* start = f->premier;
Element* temp = (Element*)malloc(sizeof(Element));

strcpy( temp->data ,tache);

temp->priorite = p;
temp->suivant=NULL;

if (f->premier==NULL)
{
f->premier=temp;
 }
else {

if ((f->premier->priorite )< (p)) {

temp->suivant = f->premier;
f->premier = temp;
}

else {
while (start->suivant != NULL && start->suivant->priorite > p) {
start = start->suivant;
}

temp->suivant = start->suivant;
start->suivant = temp;
}
}
}
//////////////////////////////////////////////////////////////////////////
int estVide(File* f) {
return (f->premier) == NULL;
}
/////////////////////////////////////////////////////////////////////
int main() {

File pq;
intialise(&pq);
// printf("hh %s" , pq.premier->data);
enfiler(&pq, "toto", 2);
enfiler(&pq, "TITI", 3);
enfiler(&pq, "TATA", 0);
while (!estVide(&pq)) {
printf("%s \n", RetourSommet(&pq));
defiler(&pq);
}
return 0;
}

Exercice 3

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

typedef struct elem

{ int val;
struct elem *suiv;
}Elem;
 typedef struct file
{ Elem *prem; // sortie
Elem *dern; // entree
}File;

///////////////////////////////////////////////////////////////
File* Initialisation(void)
{ File*f;
f=(File*)malloc(sizeof(File));
f->prem=f->dern=NULL;
return f;
}
/////////////////////////////////////////////////////////////
void enfiler(File*f, int val)
{ Elem *e;
e=(Elem*)malloc(sizeof(Elem));
e->val=val;
e->suiv=NULL;
if (f->dern==NULL)// si file vide
f->dern=f->prem=e;
else{ f->dern->suiv=e; f->dern=e; }
}
////////////////////////////////////////////////////////////////
void n_2_bin(File * F, int N)
{int t;
while(N != 0)
{ enfiler(F, N % 2);
t=N % 2;
N = (N -t)/ 2;
}
}
/////////////////////////////////////////////////////////////
int bin_2_n(File * F)
{ int N=0,i=0;
Elem*E =F->prem;
while(E != NULL)
{ N= N + E->val*pow(2,i);
i++; E = E->suiv;
}
return N;
}
///////////////////////////////////////////////////////////
void affiche_file(File*f)
{ Elem*e=f->prem;
if(f->dern==NULL)
printf("file vide");
printf("prem ->");
while(e!=NULL)
{printf("%d->",e->val);
e=e->suiv; }
 printf("dern\n");
}
/////////////////////////////////////////////////////
int main()
{
File*F; F=Initialisation();
int N;
do{
printf("Entrez un entier\n");
scanf("%d",&N);
}while (N<0);
n_2_bin(F, N);
affiche_file(F);
printf("\nF2N =%d\n",bin_2_n(F));
return 0;
}