Khalaf drhourhi

Grp2 section 1 GI

TP N°7
EXERCICE 1:
1 : on cree les structure studiant et file :
typedef struct etudiant
{
  int cne;
  char *nom;
  char *prenom;
} etudiant;

typedef struct
{
  int tete;
  int queue;
  etudiant tab[MAX];
  int taille;
} file;

2 : on cree une fonction qui initialise la file

void init_file(file *f)
{
  f->queue = 0;
  f->tete = 0;
  f->taille = 0;
}

3 :On cree une fonction qui teste si la file est vide

int file_vide(file *f)
{
  return (f->taille == 0 && f->queue == 0);
}
4 : On cree une fonction qui teste si la file est pleine
int file_pleine(file *f)
{
  return (f->queue == MAX - 1);
}

5 : on cree une fonction qui enfile dans la file

int enfiler(file *f, int nv_cne, char *nom, char *prenom)
{
  if (!file_pleine(f))
  {
    if (!file_vide(f))
    {
      f->queue++;
      f->tab[f->queue].nom = (char *)malloc(sizeof(char) *
20);
      if (f->tab[f->queue].nom == NULL)
        return -1;
      f->tab[f->queue].prenom = (char
*)malloc(sizeof(char) * 20);
      if (f->tab[f->queue].prenom == NULL)
        return -1;
      f->tab[f->queue].cne = nv_cne;
      strcpy(f->tab[f->queue].nom, nom);
      strcpy(f->tab[f->queue].prenom, prenom);
      f->taille++;
      return 1;
    }
    else
    {
      f->tab[f->queue].cne = nv_cne;
      f->tab[f->queue].nom = (char *)malloc(sizeof(char) *
20);
      if (f->tab[f->queue].nom == NULL)
        return -1;
      f->tab[f->queue].prenom = (char
*)malloc(sizeof(char) * 20);
      if (f->tab[f->queue].prenom == NULL)
        return -1;
      strcpy(f->tab[f->queue].nom, nom);
      strcpy(f->tab[f->queue].prenom, prenom);
      f->taille++;
      return 1;
    }
  }
  else
  {
    printf("la file est pleine \n");
    return 0;
  }
}

6 : fonction qui permet de remplir n element dans le file

void remplir(file *f)

{
    int n, cne;
    char *nom, *prenom;
    nom = (char *)malloc(sizeof(char) * 20);
    prenom = (char *)malloc(sizeof(char) * 20);
    printf("donner le nombre des etudiants que vous voulez
saisir :");
    scanf("%d", &n);
    int i;
    for (i = 0; i < n; i++)
    {
        printf("donner le nom que vous voulez ajouter :
");
        scanf("%s", nom);
        printf("donner le prenom que vous voulez ajouter :
");
        scanf("%s", prenom);
        printf("donner le cne que vous voulez ajouter :");
        scanf("%d", &cne);
        int res = enfiler(f, cne, nom, prenom);
        if (res == 0)
        {
            printf("la pile est pleine ;\n");
            return;
        }
        else if (res == -1)
        {
            printf("on n'a pas accès à la mémoire.\n");
            return;
        }
        else
        {
            printf("l'enfilement a réussi !\n");
        }
    }
}

7 : fonction qui reire le premier etudiant inserer dans la file

int defiler(file *f)
{
  if (f->taille == 0 || f->tete == MAX - 1)
    return -1;
  else
  {
    free(f->tab[f->tete].nom);
    free(f->tab[f->tete].prenom);
    f->tete++;
    f->taille--;
  return f->tab[f->tete -1].cne;
  }
}

8 : fonction qui affiche le contenue d’une file

void affichage(file *f)
{
  int i;
  int inter;
  if (f->taille == 0)
  {
    printf("la file est vide :");
    return;
  }
  for (i = f->tete; i <= f->queue; i++)
  {
    printf("l'etudiant : %s %s %d \n", f->tab[i].nom, f-
>tab[i].prenom, f->tab[i].cne);
  }
}

9 : fonction qui fait une recherche a un cin dans la file

int rechercher(file *f, int cne)
{
  int i;
  if (f->taille == 0)
  {
    return -1;
  }
  for (i = f->tete; i <= f->queue; i++)
  {
    if (f->tab[i].cne == cne)
      return i;
  }
  return -1;
}

10 : fonction menu qui faire apelle a tout les fontions precedant
void menu(file *f)
{
  int op, t;
  do
  {
    printf("operation = ");
    scanf("%d", &op);
    switch (op)
    {
    case 1:
    {
      init_file(f);
      printf("la pile a bien initialiser \n");
      break;
    }
    case 2:
    {
      remplir(f);
      break;
    }
    case 3:
    {
      int reso=defiler(f);
      if (reso == -1)
        printf("le defilement a echoue \n");
      else
        printf("le defilement a effectue avec succes
d'element %d \n", reso);
      break;
    }
    case 4:
    {
      affichage(f);
      break;
    }
    case 5:
    {
      int cne;
      printf("donner un cne a rechercher :");
      scanf("%d", &cne);
      if (rechercher(f, cne) != -1)
        printf("la valuer est dans le tableau avec un
indice de %d \n", rechercher(f, cne));
      else
        printf("la valeur n'existe pas \n");
      break;
    }

    default:
      printf("la valeur est invalide \n");
      break;
    }
    printf("TAPER 1 POUR RECOMMENCER :");
    scanf("%d", &t);
  } while (t == 1);
}
LE TEST DU PROGRAMME 1 :
EXERCICE 2 :
typedef struct etudiant{
    int cne;
    char *nom;
    char *prenom;
    struct etudiant *suivant;
}etudiant;

typedef struct Fiche{

    etudiant *tete;
    etudiant *queue;
    int taille;
} file;
1 : on cree une fonction qui initialise une file
void initialiser(file *f)
 {
    f->tete=NULL;
    f->queue=NULL;
    f->taille=0;
 }

2 : on cree une fonction qui enfile dans une file

 int enfiler(file *f,int nv_cne,char *nv_nom,char
*nv_prenom)
  {
    etudiant *nv=(etudiant *)malloc(sizeof(etudiant));
    if(nv==NULL) return 0;
    nv->nom=(char *)malloc(sizeof(char)*20);
    if(nv->nom ==NULL) return 0;
    nv->prenom=(char *)malloc(sizeof(char)*20);
     if(nv->prenom ==NULL) return 0;
     strcpy(nv->nom,nv_nom);
     strcpy(nv->prenom,nv_prenom);
     nv->cne=nv_cne;
    if(f->taille==0)
     {
        f->queue=nv;
        f->tete=nv;
        f->queue->suivant=NULL;
        f->taille++;
        return 1;
     }
    else
      {
        f->queue->suivant=nv;
        f->queue=nv;
        nv->suivant=NULL;
        f->taille++;
        return 1;
      }
  }

3 : on cree une function qui faire un defilemenet de la file

int defiler(file *f)
{
    if (f->taille == 0) {
        return 0; // queue is empty, return failure
    }

    etudiant *rm = f->tete;

    int removed_cne = rm->cne; // save the cne of the
removed element
    f->tete = f->tete->suivant;
    if (f->taille == 1) {
        f->queue = NULL;
    }
    free(rm->nom);
    free(rm->prenom);
    free(rm);
    f->taille--;
    if (f->taille == 0) {
        f->tete = NULL;
    }
    return removed_cne; // return the cne of the removed
element
}

4 : on cree une fonction qui affiche par recursivite la file

   void afficher_recu(file *f,etudiant *courant,int
taille,int i)
    {
       
        if(courant!=NULL)
        {
        printf("l'etudiant n°%d est : %s %s %d \
n",i+1,courant->nom,courant->prenom,courant->cne);
        afficher_recu(f,courant->suivant,f->taille,i+1);
        }
    }

5 : on cree la fonction main qui fait appel aux fonctions precedentes
void menu(file *f)
 {
    int op,t;
    do {
    printf("1: pour initialiser la pile \n");
    printf("2: pour enfiler \n");
    printf("3: pour defiler \n");
    printf("4: pour afficher \n");
    printf("operation = ");
    scanf("%d",&op);
    switch (op)
    {
    case 1:
       {
        initialiser(f);
        printf("la pile a bien initialiser \n");
        break;
       }
    case 2:
      {
        char nv_nom[20],nv_prenom[20];
        int nv_cne;
        printf("donner le nom et le prenom :");
        scanf("%s %s",nv_nom,nv_prenom);
        printf("donner le cne :");
        scanf("%d",&nv_cne);
        if(enfiler(f,nv_cne,nv_nom,nv_prenom))
         printf("l'enfilement a effectue avec succes \n");
         else
          printf("l'enfilement a echoue \n");
        break;
      }
    case 3:
      {
        int defi=defiler(f);
        if(defi==0)
         printf("le defilement a echoue \n");
        else
         printf("le defilement a effectue avec succes
d'element %d \n",defi);
        break;
      }
    case 4:
     {
        file *inter;
        inter=f;
        afficher_recu(inter,inter->tete,2,0);
        break;
     }
    default:
     printf("la valeur est invalide \n");
        break;
    }
  printf("TAPER 1 POUR RECOMMENCER :");
    scanf("%d",&t);
}while(t==1);
 }

 int main()
   {
     file f;
     menu(&f);
   }