#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <conio.h>

#include <conio2.h>

#include <time.h>

#include<unistd.h>

#include<windows.h>

typedef struct Date

{

int jour;

int mois;

int annee;

} Date;

typedef struct etablissement

{

int code;

char noun[100]; //le nom de l'établissement

char region[10]; // sa région (Est-Centre-Ouest)

} etablissement;

typedef struct Tenreg

{

int matricule;

char Nom[30];

char Prenom[30];

Date date_naissance;

char wilaya_naissance[30];

int sexe;

char groupe_sanguin[3];

Date date_recrutement;

char Grade[30];

char specialite[30];

char dernier_diplome[30];

etablissement etablissement_univ;

}Tenreg ;

typedef struct Tbloc

{

Tenreg T[1000];

int nb_enreg_inseres;

} Tbloc ;

typedef struct Entete

{

int nb_blocs;/* nombre de blocs dans le fichier = numero du dernier bloc */

int nb_enreg_inseres;

int position_libre;

} Entete;

typedef struct Fichier /* Comme l'entête n'a pas la même structure que Tenreg, donc elle doit être seule au début du fichier */

{ FILE *f;

Entete entete;

} Fichier;

/* ----------------------------------------- MACHINES ABSTRAITES --------------------------------------------- */

/*-------------- Ouverture d'un fichier --------------*/

int ouvrir(Fichier* fichier,char nomfichier[30],char c,FILE* *f) // c : le mode d'ouverture du fichier, soit 'A' (ancien) soit 'N' (nouveau)

{

if((c == 'A') || (c == 'a'))

{ *f = fopen(nomfichier, "rb+");

fread(&((*fichier).entete), sizeof(Entete), 1, *f);

}//ouverture en lecture/écriture

else if ((c == 'N') || (c == 'n'))

{

*f = fopen(nomfichier, "wb+");

(*fichier).entete.nb_blocs= 0;

(*fichier).entete.position_libre=0;

fwrite(&((*fichier).entete),sizeof(Entete),1,*f);

}//création d'un nouveau fichier en lecture/écriture

else return 0;

if(*f == NULL) return 0;

return 1;

}

/*-------------- Fermeture d'un fichier --------------*/

void fermer (FILE* f,Fichier *fichier)

{

fseek(f,0,SEEK_SET);

fwrite(&((*fichier).entete),sizeof(Entete),1,f);

fclose(f);

free(f);

}

/*------------ Modification de l'entête-------------*/

void aff_entete(Fichier *f, int i, int val)

{

switch (i)

{

case 1:

(*f).entete.nb_blocs=val;

break;

case 2 :

(*f).entete.nb_enreg_inseres=val;

break;

case 3:

(*f).entete.position_libre=val;

break;

}

}

/*---------------- Lecture de l'entête---------------*/

int entete (Fichier *f, int i)

{

switch (i)

{

case 1 :

return (*f).entete.nb_blocs;

break;

case 2 :

return (*f).entete.nb_enreg_inseres;

break;

case 3 :

return (*f).entete.position_libre;

break;

}

}

/*----------------- Lecture d'un bloc----------------*/

void lireDir(FILE* f,int N_Bloc,Tbloc *buffer)

{

fseek(f, sizeof(Entete) + (N_Bloc-1) * sizeof(Tbloc),SEEK_SET);

fread(&(*buffer),sizeof(Tbloc),1, f);

}

/*----------------- Ecriture d'un bloc----------------*/

void ecrireDir(FILE* f,int N_Bloc,Tbloc *buffer)

{

fseek(f,sizeof(Entete)+(N_Bloc-1)*sizeof(Tbloc),SEEK_SET);

fwrite(&(*buffer),sizeof(Tbloc),1,f);

}

/*------------- Allocation d'un nouveau bloc ---------*/

int alloc_bloc(Fichier fichier) // au faite on n'aura pas besoin de ce module car je fais aff_entete et j'incrémente le i dans l'algorithme

{

aff_entete(&fichier,1,entete(&fichier,1)+1);

return entete(&fichier,1);

}

void chargement_initial (int N, int b) // N: le nombre d'enregistrements qu'on veut charger ; b: la taille maximale du bloc

{

Tbloc Buf; char tab[26];

int a =0;

while (a<26) //tableau de l'alphabet pour génerer les noms/prénoms

{

for (char c='a';c<='z';c++)

{

tab[a]=c;

a++;

};

};

typedef struct wilaya

{

char name[40];

}wilaya;

wilaya w[48]; // Tableau des 48 Wilayas ordonnées

FILE* g=fopen("wilaya.txt","r");

if (g !=NULL)

{

int l=0;

while (!feof(g))

{

fscanf(g,"%s",&w[l].name);

l++;

}

fclose(g);

}

typedef struct gr_sang //le groupe sanguin

{ char sang[10];

}gr_sang;

gr_sang sanguin[8]; // Tableau des groupes sanguins

strcpy(sanguin[0].sang,"O+");

strcpy(sanguin[1].sang,"A+");

strcpy(sanguin[2].sang,"B+");

strcpy(sanguin[3].sang,"O-");

strcpy(sanguin[4].sang,"A-");

strcpy(sanguin[5].sang,"AB+");

strcpy(sanguin[6].sang,"B-");

strcpy(sanguin[7].sang,"AB-");

typedef struct gr_ade // le grade

{ char gr[40];

}gr_ade;

gr_ade grade[6]; // Tableau de grade des enseignants

strcpy(grade[0].gr,"Professeur(e)");

strcpy(grade[1].gr,"Maitre de conferences Rang A");

strcpy(grade[2].gr,"Maitre de conferences Rang B");

strcpy(grade[3].gr,"Maitre assistant(e) Rang A");

strcpy(grade[4].gr,"Maitre assistant(e) Rang B");

strcpy(grade[5].gr,"Assistant(e)");

typedef struct speciality // la spécialité

{

char specialism[30];

}speciality;

speciality s[20]; // Tableau des différentes spécialités

FILE* h=fopen("specialite.txt","r");

if (h!=NULL)

{

int l=0;

while(!feof(h))

{

fscanf(h,"%s",&s[l].specialism);

l++;

}

fclose(h);

};

typedef struct der_dip // dernier diplôme

{

char t[40];

}der_dip;

der_dip tableau[5]; // Tableau des derniers diplômes

strcpy(tableau[0].t,"Doctorat d'etat");

strcpy(tableau[1].t,"Doctorat en sciences");

strcpy(tableau[2].t,"PhD");

strcpy(tableau[3].t,"HDR");

strcpy(tableau[4].t,"Magistère");

etablissement etab[108];// Tableau des établissements existant en Algérie, on a trouvé 107 établissements et pas 106

FILE* p=fopen("etablissement1.txt","r");

if (p!=NULL)

{

int a=0;

while((a<108))

{

fscanf(p,"%d %s %s",&etab[a].code,&etab[a].noun,&etab[a].region);

a++;

if(a==100)

{

p=fopen("etablissement2.txt","r");

if (p!=NULL)

{

while (a<108)

{

fscanf(p,"%d %s %s",&etab[a].code,&etab[a].noun,&etab[a].region);

a++;

}

fclose(p);

}

};

};

fclose(p);

}

FILE* f;

Fichier fi;

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'n',&f);

int j=0; int i=1;

for (int k=1;k<=N;k++)

{

if (j<b) // les indices du tableau commencent àa partir de 0 jusqu'à b-1, ie, il y a b éléments dans le tableau

{

/* ---------- Génération du matricule -------- */

Buf.T[j].matricule= (rand()%888889)+111111; // random génère un nombre entre [0,888889[ donc on rajoute 1 à (999999-111111=888888) pourque 999999 soit inclus

/* ---------- Génération du Nom/Prénom -------- */

for (int m=0;m<=rand()%27 +4;m++) //on genère un nombre entre 4 et 30 (ce nombre étant le nb de char pour le nom/prenom) et pour chaque

{ //caractère on genère un nombre entre 1 et 26 et on met dans ce char la lettre qui correspond*/

Buf.T[j].Nom[m]=tab[rand()%26];

};

for (int n=0;n<=rand()%27 +4;n++)

{

Buf.T[j].Prenom[n]=tab[rand()%26];

};

/* ---------- Génération de la date de naissance-------- */

Buf.T[j].date_naissance.annee= (rand()%40)+1953 ;

Buf.T[j].date_naissance.mois= (rand()%12)+1 ;

int Mois=Buf.T[j].date_naissance.mois;

if ((Mois==1) ||(Mois==3) || (Mois==5)|| (Mois==7) || (Mois==8) || (Mois==10) || (Mois==12))

{

Buf.T[j].date_naissance.jour=(rand()%31)+1;

};

if ((Mois==4)|| (Mois==6)|| (Mois==9)||(Mois==11))

{

Buf.T[j].date_naissance.jour=(rand()%30)+1;

};

if (Mois==2) // cas particulier pour le mois de Février (selon les années :bissextiles ou non-bissextiles

{

int annee=Buf.T[j].date_naissance.annee;

if ((annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0)) // Si l'année est bissextile

{

Buf.T[j].date_naissance.jour=(rand()%29)+1; // Dans ce cas on aura un jour en plus qui le 29 février

}

else // l'année n'est pas bissextile

Buf.T[j].date_naissance.jour=(rand()%28)+1; // Dans ce cas on aura 28 jours pour le mois de Févrirer

};

/* ---------- Génération de la Wilaya de naissance-------- */

strcpy(Buf.T[j].wilaya_naissance,w[rand()%48].name);

/* ---------- Génération du sexe-------- */

Buf.T[j].sexe=rand()%2 +1;

/* ---------- Génération du groupe sanguin ------- */

strcpy(Buf.T[j].groupe_sanguin,sanguin[rand()%7+1].sang);

/* ---------- Génération de la date de recrutement ------- */

Buf.T[j].date_recrutement.annee= (rand()%40)+1979 ;

Buf.T[j].date_recrutement.mois= (rand()%12)+1 ;

int mois=Buf.T[j].date_recrutement.mois;

if ((mois==1) ||(mois==3) || (mois==5)|| (mois==7) || (mois==8) || (mois==10) || (mois==12))

{

Buf.T[j].date_recrutement.jour=(rand()%31)+1; // les mois ayant 31 comme dernier jour

};

if ((mois==4)|| (mois==6)|| (mois==9)||(mois==11)) // les mois ayant 30 comme dernier jour

{

Buf.T[j].date_recrutement.jour=(rand()%30)+1;

};

if (mois==2) // cas particulier pour le mois de Février (selon les années :bissextiles ou non-bissextiles)

{

int annee=Buf.T[j].date_recrutement.annee;

if ((annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0)) // Si l'année est bissextile

{

Buf.T[j].date_recrutement.jour=(rand()%29)+1;

}

else // l'année n'est pas bissextile

Buf.T[j].date_recrutement.jour=(rand()%28)+1;

};

/* ---------- Génération du grade -------- */

strcpy(Buf.T[j].Grade,grade[rand()%6+1].gr);

/* ---------- Génération de spécialité -------- */

strcpy(Buf.T[j].specialite,s[rand()%5+1].specialism);

/* ---------- Génération du dernier diplôme -------- */

strcpy(Buf.T[j].dernier_diplome,tableau[rand()%5].t);

/* ---------- Génération de l'établissement univ -------- */

int c=rand()%108;

strcpy(Buf.T[j].etablissement_univ.noun,etab[c].noun); // on doit garder le même indice de l'établissement choisi pour récuperer sa région correspondnate

strcpy(Buf.T[j].etablissement_univ.region,etab[c].region);

Buf.T[j].etablissement_univ.code=c;

j++;

}

else // j>=b, si j=b (j=1000 pour notre cas), 'élément T[1000] n'existe pas dans le tableau car les indices varient de 0 jusqu'à 999

{

Buf.nb_enreg_inseres=j ;//On rentre dans ce sinon avec j=b (j=1000) dans le nb_enreg_inseres dans le bloc est 1000

ecrireDir(f,i,&Buf);

/* ---------- Génération du matricule -------- */

Buf.T[0].matricule= (rand()% 888889)+111111;

/* ---------- Génération du Nom/Prénom -------- */

for (int m=0;m<=rand()%27 +4;m++) //on genère un nombre entre 4 et 30 (ce nombre étant le nb de char pour le nom/prenom) et pour chaque

{ //caractère on genère un nombre entre 1 et 26 et on met dans ce char la lettre qui correspond*/

Buf.T[0].Nom[m]=tab[rand()%26];

};

for (int n=0;n<=rand()%27 +4;n++)

{

Buf.T[0].Prenom[n]=tab[rand()%26];

};

/* ---------- Génération de la date de naissance-------- */

Buf.T[0].date_naissance.annee= (rand()%40)+1953 ;

Buf.T[0].date_naissance.mois= (rand()%12)+1 ;

int Mois=Buf.T[0].date_naissance.mois;

if ((Mois==1) ||(Mois==3) || (Mois==5)|| (Mois==7) || (Mois==8) || (Mois==10) || (Mois==12))

{

Buf.T[0].date_naissance.jour=(rand()%31)+1;

};

if ((Mois==4)|| (Mois==6)|| (Mois==9)||(Mois==11))

{

Buf.T[0].date_naissance.jour=(rand()%30)+1;

};

if (Mois==2) // cas particulier pour le mois de Février (selon les années :bissextiles ou non-bissextiles

{

int annee=Buf.T[0].date_naissance.annee;

if ((annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0)) // Si l'année est bissextile

{

Buf.T[0].date_naissance.jour=(rand()%29)+1; // Dans ce cas on aura un jour en plus qui le 29 février

}

else // l'année n'est pas bissextile

Buf.T[0].date_naissance.jour=(rand()%28)+1; // Dans ce cas on aura 28 jours pour le mois de Févrirer

};

/* ---------- Génération de la Wilaya de naissance-------- */

strcpy(Buf.T[0].wilaya_naissance,w[rand()%48].name);

/* ---------- Génération du sexe-------- */

Buf.T[0].sexe=rand()%2+1;

/* ---------- Génération du groupe sanguin ------- */

strcpy(Buf.T[0].groupe_sanguin,sanguin[rand()%8].sang);

/* ---------- Génération de la date de recrutement ------- */

Buf.T[0].date_recrutement.annee= (rand()%40)+1979 ;

Buf.T[0].date_recrutement.mois= (rand()%12)+1 ;

int mois=Buf.T[0].date_recrutement.mois;

if ((mois==1) ||(mois==3) || (mois==5)|| (mois==7) || (mois==8) || (mois==10) || (mois==12))

{

Buf.T[0].date_recrutement.jour=(rand()%31)+1; // les mois ayant 31 comme dernier jour

};

if ((mois==4)|| (mois==6)|| (mois==9)||(mois==11)) // les mois ayant 30 comme dernier jour

{

Buf.T[0].date_recrutement.jour=(rand()%30)+1;

};

if (mois==2) // cas particulier pour le mois de Février (selon les années :bissextiles ou non-bissextiles)

{

int annee=Buf.T[0].date_recrutement.annee;

if ((annee % 4 == 0 && annee % 100 != 0) || (annee % 400 == 0)) // Si l'année est bissextile

{

Buf.T[0].date_recrutement.jour=(rand()%29)+1;

}

else // l'année n'est pas bissextile

Buf.T[0].date_recrutement.jour=(rand()%28)+1;

};

/* ---------- Génération du grade -------- */

strcpy(Buf.T[0].Grade,grade[rand()%6].gr);

/* ---------- Génération de spécialité -------- */

strcpy(Buf.T[0].specialite,s[rand()%5].specialism);

/* ---------- Génération du dernier diplôme -------- */

strcpy(Buf.T[0].dernier_diplome,tableau[rand()%5].t);

/* ---------- Génération de l'établissement univ -------- */

int c=rand()%108;

strcpy(Buf.T[0].etablissement_univ.noun,etab[c].noun); // on doit garder le même indice de l'établissement choisi pour récuperer sa bonne région

strcpy(Buf.T[0].etablissement_univ.region,etab[c].region);

Buf.T[j].etablissement_univ.code=c;

j=1;

i++;

};

};

Buf.nb_enreg_inseres=j;

ecrireDir(f,i,&Buf);

aff_entete(&fi,1,i);

aff_entete(&fi,2,N);

aff_entete(&fi,3,Buf.nb_enreg_inseres);//nb_enreg_inseres du dernier bloc est l'indice de la 1ere position libre

fermer(f,&fi);

}

/* ---------- Epuration ---------- */

/*Pour l'épuration, on a choisit une méthode qui est la plus optimale (en nombre d'accés à la mémoire secondaire,le temps d'acces..etc) et qui est

divisée en 4 étapes:

1- Remplissage de la table d'index : on remplit la table d'index avec tous les matricules (index dense) en parcourant tout le fichier bloc par bloc.

2- Tri par bulles: on trie la table d'index (en ordre croissant).

3- Suppression des doublons du fichier.

4- Suppression des doublons de la table d'index (par décalage).*/

typedef struct tableau // tableau ; va contenir tous les matricules avec les numeros de blocs (i) pour chaque matricule et sa position (j)

{

int matricule;

int i;

int j;

}tableau;

typedef struct maillon *ptr; /*cette structure et ces machines abstraites seront utilisées pour la prochaine question et celàa afin d'éviter de redéclarer

des structures presque identiques sauf qu'on va pas utiliser le champs "code" pour cette question, on a juste besoin du i et du j.*/

struct maillon{

int code;

int i;

int j;

ptr suiv;

};

ptr Allouer(ptr *p)

{

*p = (struct maillon *) malloc( sizeof( struct maillon)) ;

(*p)->suiv = NULL;

}

void aff_val(ptr p,int i,int val)

{

switch (i)

{

case 1:

p->code=val;

break;

case 2:

p->i=val;

break;

case 3:

p->j=val;

break;

}

}

void aff_adr(ptr p,ptr q)

{

p->suiv=q;

}

ptr suivant( ptr p)

{ return( p->suiv); }

int valeur(ptr p, int i)

{

switch (i)

{

case 1:

return (p->code);

break;

case 2:

return (p->i);

break;

case 3:

return (p->j);

break;

}

}

void liberer(ptr p)

{

free(p);

}

typedef struct branche

{

char speciality[30];

ptr tete;

}branche;

void swap (tableau T[],int a, int b) // swap two elements of the array

{

tableau temp;

temp.i=T[a].i;

temp.j=T[a].j;

temp.matricule=T[a].matricule;

T[a].i=T[b].i;

T[a].j=T[b].j;

T[a].matricule=T[b].matricule;

T[b].i=temp.i;

T[b].j=temp.j;

T[b].matricule=temp.matricule;

}

void tri_bulles(tableau T[],int N) // Pour trier le tableau des matricules en ordre croisssant

{

int tab_en_ordre = 0;

while(tab_en_ordre!=1)

{

tab_en_ordre = 1;

for(int k=0 ; k < N-1 ; k++)

{

if(T[k].matricule > T[k+1].matricule)

{

swap(T,k,k+1);

tab_en_ordre = 0;

}

}

N--;

}

}

void index_specialite()

{

Fichier fi;FILE *f;Tbloc buff;

ptr tete,p,q;

FILE *g=fopen("specialite.txt","r");

branche brch[20];

int k=0;

if (g!=NULL)

{

while (!feof(g)) // initialisation de la table d'index

{

fscanf(g,"%s",&brch[k].speciality);

brch[k].tete=NULL;

k++;

}

fclose(g);

};

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'a',&f);

int i=1;int j;

while (i<=entete(&fi,1)) // construction de la table d'index

{

lireDir(f,i,&buff);

j=0;

while (j<buff.nb_enreg_inseres)

{

k=0;

while (strcmp(buff.T[j].specialite,brch[k].speciality)!=0)

{

k++;

};

if (brch[k].tete==NULL) //liste vide

{

Allouer(&tete);

aff_val(tete,2,i);

aff_val(tete,3,j);

aff_adr(tete,NULL);

brch[k].tete=tete;

}

else // tete!=NULL

{

q=brch[k].tete;

while (suivant(q)!=NULL)

{

q=suivant(q);

};

Allouer(&p);

aff_val(p,2,i);

aff_val(p,3,j);

aff_adr(q,p);

aff_adr(p,NULL);

};

j++;

};

i++;

};

fermer(f,&fi);

/* ------ sauvegarde de la table d'index ------ */

g=fopen("fichier_index2.txt","w");

k=0;

if (g!=NULL)

{

while (k<20)

{

fprintf(g,"%s %p\n",brch[k].speciality,brch[k].tete);

k++;

}

}

fclose(g);

}

typedef struct vecteur{

int anciennete;

ptr tete;

}vecteur;

void index_anciennete(int current_year)

{

int max=current_year-1979;

vecteur tab[max+1]; // on met "max+1" éléments pour avoir ancienneté entre 0 et max, car si on met max on aura ancienneté entre 0 et max-1

int k=0; // on considère ancienneté=0 pour les enseignants recrutés au cours de l'année courrante

while (k<max+1)

{

tab[k].anciennete=k; // on mesure l'ancienneté par an

tab[k].tete=NULL; // on initialise les têtes à NULL

k++;

}

Fichier fi; FILE* f; Tbloc buff; int i,j,anciennete;

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'a',&f);

ptr tete,p,q;

i=1;

while (i<=entete(&fi,1)) // on parcourt tout le fichier et pour chaque enregistrement on calcule son ancienneté et on l'affecte à la liste dans la table d'index

{

lireDir(f,i,&buff);

j=0;

while (j<buff.nb_enreg_inseres)

{

anciennete= current_year - buff.T[j].date_recrutement.annee;

if (tab[anciennete].tete==NULL) // liste vide // l'indice ancienneté correspond à la case qui contient la valeur "ancienneté"

{

Allouer(&tete);

aff_val(tete,1,buff.T[j].etablissement_univ.code);

aff_val(tete,2,i);

aff_val(tete,3,j);

tab[anciennete].tete=tete;

aff_adr(tete,NULL);

}

else // tête != NULL

{

Allouer(&p);

aff_val(p,1,buff.T[j].etablissement_univ.code);

aff_val(p,2,i);

aff_val(p,3,j);

q=tab[anciennete].tete;

while (suivant(q)!=NULL)

{

q=suivant(q);

}; // on sort de la boucle avec un pointeur vers le dernier maillon (suivant(q)==NULL)

aff_adr(q,p);

aff_adr(p,NULL);

};

j++;

}

i++;

};

fermer(f,&fi);

/* ----- sauvgarde de l'index ----- */

k=0;

FILE* h=fopen("fichier_index3.txt","w");

if (h!=NULL)

{

while (k<max+1)

{

fprintf(h,"%d %p\n",tab[k].anciennete,tab[k].tete);

k++;

};

fclose(h);

}

}

typedef struct table // strucuture de la table d'index

{

char region[10];

ptr tete;

}table;

void index_region()

{

table index[3]; //initialisation de la table d'index

strcpy(index[0].region,"est");

strcpy(index[1].region,"centre");

strcpy(index[2].region,"ouest");

int k=0;

while (k<3)

{

index[k].tete=NULL;

k++;

};

Fichier fi; FILE *f; Tbloc buff;

ptr tete,p,q;

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'a',&f);

int i=1; int j;

while (i<=entete(&fi,1)) // initilisation des listes et affectation des têtes à la table d'index

{

lireDir(f,i,&buff);

j=0;

while (j<buff.nb_enreg_inseres)

{

if (strcmp(buff.T[j].etablissement_univ.region,"est")==0) // la région de l'établissement d'exercice de cet enseignant est "est"

{

if (index[0].tete==NULL)//liste vide

{

Allouer(&tete);

aff_val(tete,2,i); //on affecte le numero de bloc

aff_val(tete,3,j); // ona ffecte la position

index[0].tete=tete;

aff_adr(tete,NULL);

}

else // tête!=NULL

{

Allouer(&p);

aff_val(p,2,i);

aff_val(p,3,j);

q=index[0].tete; // q pointe la tête de la liste

while (suivant(q)!=NULL) //parcours de la liste pour extraire le dernier maillon

{

q=suivant(q);

}

aff_adr(q,p);

aff_adr(p,NULL);

}

};

if (strcmp(buff.T[j].etablissement_univ.region,"centre")==0) // la région de l'établissement d'exercice de cet enseignant est "est"

{

if (index[1].tete==NULL)//liste vide

{

Allouer(&tete);

aff_val(tete,2,i); //on affecte le numero de bloc

aff_val(tete,3,j); // ona ffecte la position

index[1].tete=tete;

aff_adr(tete,NULL);

}

else // tête!=NULL

{

Allouer(&p);

aff_val(p,2,i);

aff_val(p,3,j);

q=index[1].tete; // q pointe la tête de la liste

while (suivant(q)!=NULL) //parcours de la liste pour extraire le dernier maillon

{

q=suivant(q);

}

aff_adr(q,p);

aff_adr(p,NULL);

}

};

if (strcmp(buff.T[j].etablissement_univ.region,"ouest")==0) // la région de l'établissement d'exercice de cet enseignant est "est"

{

if (index[2].tete==NULL)//liste vide

{

Allouer(&tete);

aff_val(tete,2,i); //on affecte le numero de bloc

aff_val(tete,3,j); // ona ffecte la position

index[2].tete=tete;

aff_adr(tete,NULL);

}

else // tête!=NULL

{

Allouer(&p);

aff_val(p,2,i);

aff_val(p,3,j);

q=index[2].tete; // q pointe la tête de la liste

while (suivant(q)!=NULL) //parcours de la liste pour extraire le dernier maillon

{

q=suivant(q);

}

aff_adr(q,p);

aff_adr(p,NULL);

}

};

j++;

}

i++;// on incrémente le num de bloc

};

fermer(f,&fi);

/* -------- sauvgarde de la table d'index --------- */

FILE *g=fopen("fichier_index4.txt","w");

if (g!=NULL)

{

k=0;

while (k<3)

{

fprintf(g,"%s %p\n",index[k].region,index[k].tete);

k++;

};

fclose(g);

};

}

void Epuration(int current_year)

{

Fichier fi; FILE* f; int i=1;int j; // i est le numero de bloc, j est la position

Tbloc buff1;Tbloc buff2;//buff1 est utilisé dans la suite pour le dernier bloc, buff2 pour le bloc qui contient un doublon à supprimer

int k=0; //k est l'indice de la table d'index

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'a',&f);

int taille=fi.entete.nb_enreg_inseres;

tableau t[taille];

/* ----------- initialisation de la table d'index des matricules ------------ */

while (i<=entete(&fi,1)) // on parcourt tous les blocs pour récupérer tous les matricules

{

lireDir(f,i,&buff1);

j=0;

while (j<buff1.nb_enreg_inseres) // On récupère les matricules du bloc i

{

t[k].matricule=buff1.T[j].matricule;

t[k].j=j;

t[k].i=i;

j++;

k++;

}

i++;

};

/* ----------- Tri par bulles ------------ */

tri_bulles(t,taille);

int a=0;

while (a<taille-1) // on parcourt le tableau qui est ordonné en ordre croissant et on compare chaque élément avec son suivant s'ils ont le mm matricule ou pas

{

if (t[a].matricule==t[a+1].matricule)

{

/* ----------- suppression des doublons du fichier ----------- */

j=t[a].j;

lireDir(f,t[a].i,&buff2);

lireDir(f,entete(&fi,1),&buff1); //On doit toujours relire le dernier bloc car il est mis à jour aprés chaque suppression

buff2.T[j].matricule=buff1.T[buff1.nb_enreg_inseres-1].matricule; // on remplace le doublon par le dernier element du dernier bloc (suppression physique)

strcpy(buff2.T[j].Nom,buff1.T[buff1.nb_enreg_inseres-1].Nom);

strcpy(buff2.T[j].Prenom,buff1.T[buff1.nb_enreg_inseres-1].Prenom);

buff2.T[j].sexe=buff1.T[buff1.nb_enreg_inseres-1].sexe;

buff2.T[j].date_naissance.annee=buff1.T[buff1.nb_enreg_inseres-1].date_naissance.annee;

buff2.T[j].date_naissance.mois=buff1.T[buff1.nb_enreg_inseres-1].date_naissance.mois;

buff2.T[j].date_naissance.annee=buff1.T[buff1.nb_enreg_inseres-1].date_naissance.jour;

strcpy(buff2.T[j].wilaya_naissance,buff1.T[buff1.nb_enreg_inseres-1].wilaya_naissance);

strcpy(buff2.T[j].specialite,buff1.T[buff1.nb_enreg_inseres-1].specialite);

strcpy(buff2.T[j].groupe_sanguin,buff1.T[buff1.nb_enreg_inseres-1].groupe_sanguin);

strcpy(buff2.T[j].Grade,buff1.T[buff1.nb_enreg_inseres-1].Grade);

strcpy(buff2.T[j].dernier_diplome,buff1.T[buff1.nb_enreg_inseres-1].dernier_diplome);

strcpy(buff2.T[j].etablissement_univ.noun,buff1.T[buff1.nb_enreg_inseres-1].etablissement_univ.noun);

strcpy(buff2.T[j].etablissement_univ.region,buff1.T[buff1.nb_enreg_inseres-1].etablissement_univ.region);

buff2.T[j].etablissement_univ.code=buff1.T[buff1.nb_enreg_inseres-1].etablissement_univ.code; // on remplace le doublon par le dernier element du dernier bloc (suppression physique)

buff2.T[j].date_recrutement.annee=buff1.T[buff1.nb_enreg_inseres-1].date_recrutement.annee;

buff2.T[j].date_recrutement.mois=buff1.T[buff1.nb_enreg_inseres-1].date_recrutement.mois;

buff2.T[j].date_recrutement.annee=buff1.T[buff1.nb_enreg_inseres-1].date_recrutement.jour;

ecrireDir(f,t[a].i,&buff2); //on écrit le bloc modifié

aff_entete(&fi,2,entete(&fi,2)-1); // on décrémente le nb_enregistrments_insérés

if (buff1.nb_enreg_inseres==1)

{

aff_entete(&fi,1,entete(&fi,1)-1); //on supprime le dernier bloc car il contient un seul enregistrement

aff_entete(&fi,3,buff2.nb_enreg_inseres); //on détaillera pourquoi on a mis taille dans le module insertion.

}

else {

buff1.nb_enreg_inseres--;

aff_entete(&fi,3,buff1.nb_enreg_inseres);

ecrireDir(f,entete(&fi,1),&buff1);

};

fermer(f,&fi);

/* -------- suppression des doublons de la table d'index -------- */

k=a;

while (k<taille-1)

{

t[k].matricule=t[k+1].matricule;

t[k].i=t[k+1].i;

t[k].j=t[k+1].j;

k++;

}

taille--;

}

else { // T[a]!= T[a+1]

a++;

}

};

fermer(f,&fi);

/* ------ sauvegarde de l'index des matricules ------ */

FILE* g=fopen("fichier_index1.txt","w");

a=0;

if (g!=NULL){

while (a<taille)

{

fprintf(g,"%d %d %d\n",t[a].matricule,t[a].i,t[a].j);

a++;

};

};

fclose(g);

/* -------- initialisation des index ---------- */

index_specialite();

index_anciennete(current_year);

index_region();

}

/* ---------------- Ajout d'un enseignant ---------------- */

/*On récupère la 1ere position libre depuis l'entête, ensuite on vérifie: si j<buff.nb_enreg_inseres on insère dans ce bloc, sinon on insère

dans un nouveau bloc avec j=0 */

void Rech_Dicho_1(int matricule, int *trouv,int *i,int *j,int *pos) // Recherche dichotomique du matricule dans la table d'index

{

Fichier fi; FILE* f;

ouvrir(&fi,"ENSEIGNANT-MESRS.dat",'a',&f);

int taille=fi.entete.nb_enreg_inseres;

fermer(f,&fi);

tableau T[taille]; // on alloue une table d'index de taille nb_enreg_insérés

FILE* m=fopen("fichier_index1.txt","r"); //chargement de la table d'index

if (m!=NULL)

{ int k=0;

while (!feof(m)) // chargement de la table d'index

{

fscanf(m,"%d %d %d",&T[k].matricule,&T[k].i,&T[k].j);

k++;

};

fclose(m);

}

int inf=0; int sup=taille-1;

int milieu;

(*trouv)=0;

while ((inf<=sup) && ((*trouv)==0))

{

milieu=(inf+sup)/2;

if (matricule==T[milieu].matricule)

{

(*trouv)=1;

(*j)=T[milieu].j;

(*i)=T[milieu].i;

(*pos)=milieu;

}

else {

if (matricule<T[milieu].matricule)

{

sup=milieu-1;

};

if (matricule>T[milieu].matricule)

{

inf=milieu+1;

};

};

};

}

void Ajout_index_specialite(int i,int j,char speciality[30])

{