NF16

Correction du TD 7
9 mai 2015
Exercice 1. Crible d'Erastosthne :

1
2
3
4
5
6
7
8
9
10
11
12

# include < stdio .h >

# include < stdlib .h >
int main ()
{
int i ,j , n ;
// cration d ' un tableau de taille n +1
// la fin du programme ,
// tab [ i ]==0 si i est premier et 1 sinon .
scanf ( " % d " , & n ) ;
char * tab =( char *) calloc ( n +1 ,1) ; // les cases sont initialises
'0'

13

tab [0]= tab [1]=1; /* ne sont pas premiers */

/* Barrer les multiples de 2 */
for ( i =4; i <= n ; i +=2) tab [ i ]=1;

14
15
16
17

printf ( " 2 est premier \ n " ) ;

18
19
20
21
22
23
24
25
26
27
28
29
30

for ( i =3; i <= n ; i +=2)

{
if (! tab [ i ]) {
// i est premier , il faut barrer ses multiples
for ( j =2* i ; j <= n ; j += i ) tab [ j ]=1;
printf ( " % d est premier \ n " ,i ) ;
}
}
free ( tab ) ;
return 0;

31
32
33
34

35

/*
void * calloc ( int nb_elem , int taille1 ) dans < stdlib .h > < malloc .h >
rserve une zone mmoire dont la taille en octets est nb_elem
* taille1 tous les lments sont initialiss 0
*/

Exercice 2. Problme de Josephus :

1
2
3
4
5
6
7
8
9
10
11
12
13
1
2

struct noeud {
int cle ;
struct noeud * succ ;
};
struct noeud * creer_noeud ( int cle ) {
struct noeud * p ;
if (( p =( struct noeud *) malloc ( sizeof ( struct noeud ) ) ) == NULL )
printf ( " erreur allocation memoire \ n ") ;
else p - > cle = cle ;
return p ;
}
void elimine ( int N , int M ) {
int i ;

// creation d ' une liste simplement chainee circulaire .

// premier noeud
struct noeud * tete = creer_noeud (1) ;
// creation du reste de la liste
struct noeud * prec = tete ;
struct noeud * p ;
for ( i =2; i <= N ; i ++) {
p = creer_noeud ( i ) ;
prec - > succ = p ;
prec = p ;
}
// la liste est circulaire = > on attache les deux bouts
prec - > succ = tete ;

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
1
2
3
4
5

// *** elimination tous les M ***

while ( tete - > succ != tete ) {
// aller au Mime
for ( i =1; i < M ; i ++) { prec = tete ; tete = tete - > succ ;}
// elimination du noeud tete
prec - > succ = tete - > succ ;
printf ( " elimine le % d \ n " , tete - > cle ) ;
free ( tete ) ;
tete = prec - > succ ; // la tete devient le suivant
}
// elimination du dernier
printf ( " elimine le % d \ n " , tete - > cle ) ;
free ( tete ) ;
return ;

int main ()
{
elimine (9 ,5) ;
return 0;
}

Exercice 3. Liste doublement chane avec sentinelle :

1
2
3
4
5
6
7

typedef struct element {

int cle ;
struct element * suiv ;
struct element * prec ;
}* Element ;
Element sentinelle ;
Fonctions :

1
2
3
4
5
6
1
2
3
4

Element Creer_Liste_Vide () ;
void InsererElement ( Element tete , Element nouveau ) ;
void SupprimerElement ( Element e ) ;
Element CreerElement ( int cle ) ;
void AfficherListe ( Element tete ) ;
void SupprimerListe ( Element tete ) ;
/* Crer la sentinelle */
Element Creer_Liste_Vide ()
{
Element E ;

/* alloue la mmoire pour E ( la sentinelle ) */

E = ( Element ) malloc ( sizeof ( struct element ) ) ;

6
7
8

/* Valeurs initiales pour les pointeurs */

E - > cle = -1; E - > prec = E ; E -> suiv = E ;

9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

return E ;

/* Insetion d ' un lment */

void InsererElement ( Element tete , Element nouveau )
{
/* 1 er cas : la sentinelle n ' est pas cre */
if ( tete == NULL ) return ;
/* 2 me cas : la liste est vide */
if ( tete - > suiv == tete )
{
tete - > suiv = nouveau ;
tete - > prec = nouveau ;
nouveau -> suiv = tete ;
nouveau -> prec = tete ;
return ;
}
/* 3 me cas : la liste n ' est pas vide , on insre la fin de la
liste */
if ( tete - > suiv != tete )
{
nouveau -> prec = tete - > prec ;
tete - > prec - > suiv = nouveau ;
tete - > prec = nouveau ;
nouveau -> suiv = tete ;
3

25
26
27
1
2
3
4
5
6
7
1
2
3
4
5
6
1
2
3
4

}
void SupprimerElement ( Element e )
{
e - > prec - > suiv = e - > suiv ;
e - > suiv - > prec = e - > prec ;
printf ( " je supprime la cl : % d \ n " , e - > cle ) ;
free ( e ) ;
}
Element CreerElement ( int cle )
{
Element e = ( Element ) malloc ( sizeof ( struct element ) ) ;
e - > cle = cle ;
return e ;
}
void AfficherListe ( Element tete )
{
Element iter ;

if ( tete == NULL ) { printf ( " La sentinelle = NULL \ n " ) ; return ;}

6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
1
2
3

void SupprimerListe ( Element tete )

{
while ( tete - > suiv != tete )
{
SupprimerElement ( tete - > suiv ) ; /* on supprimer le 1 er elt de la
liste */
}
/* on ne doit pas ( par principe ) supprimer la tete ici */
}
int main ()
{
int i ;

sentinelle = Creer_Liste_Vide () ;
for ( i =0; i <10; i ++)
InsererElement ( sentinelle , CreerElement ( i ) ) ;
AfficherListe ( sentinelle ) ;
SupprimerListe ( sentinelle ) ;

5
6
7
8
9
10
11
12
13

iter = tete - > suiv ;

while ( iter != tete )
{
printf ( " % d " , iter - > cle ) ;
iter = iter - > suiv ;
}
printf ( " \ n " ) ;

/* on supprime la sentinelle ici */

free ( sentinelle ) ; sentinelle = NULL ;

Exercice 4. Piles :

1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# define MAX_P

typedef struct pile {

int sommet ;
int tab [ MAX_P ];
} pile ;
pile creerpile ( int max ) ;
int pilevide ( pile * p ) ;
int pilepleine ( pile * p ) ;
int empiler ( pile *p , int x ) ;
int depiler ( pile * p ) ;
void supprimerpile ( pile * p ) ;
pile creerpile ( int max ) {
pile P =( pile *) malloc ( max * sizeof ( struct pile ) ) ;
if ( P == NULL ) printf ( " allocation impossible \ n " ) ;
else P - > sommet = -1;
return P ;
}
/* --------------------------------------------------- */
int pilevide ( pile * p ) {
if (p - > sommet == -1) return 1;
else return 0;
}
/* --------------------------------------------------- */
int pilepleine ( pile * p ) {
if (p - > sommet == ( MAX_P -1) ) return 1;
else return 0;
}
/* --------------------------------------------------- */
int empiler ( pile *p , int x ) {
if ( pilepleine ( p ) ) {
printf ( " erreur : la pile est pleine \n " ) ;
return 0;
}
p - > sommet = p - > sommet + 1;
p - > tab [ p - > sommet ] = x ;
return 1;
}
/* --------------------------------------------------- */
int depiler ( pile * p ) {
if ( pilevide ( p ) ) {
printf ( " erreur : la pile est vide \ n ") ;
return 0;
}
p - > sommet - -;
return (p - > tab [p - > sommet +1]) ;
}
/* --------------------------------------------------- */

42
43
44

void supprimerpile ( pile * p ) {

free ( p ) ;
}

Exercice 5. Notation polonaise :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

int calcul ( char * exp ) {

/* on suppose que exp est une chaine de caractres correspondant
une expression crite en utilisant la polonaise inverse .
La fonction renvoie un int gal au rsultat du calcul .
On supposera que seuls les entiers positifs et les oprations + * / sont utilises */
int nb , k =0;
struct * pile = creer_pile () ;
while ( exp [ k ]!= ' \0 ') {
if ( exp [ k ] >= '0 ' && exp [ k ] <= '9 ') { /* c ' est un nb */
/* extraction du nb */
nb =0;
while ( exp [ k ] >= '0 ' && exp [ k ] <= '9 ') {
nb = nb *10;
nb = nb +( exp [ k ] - '0 ') ;
k ++;
}
Empiler (p , nb ) ;
}
else { /* c ' est un espace ou un oprateur */
if ( exp [ k ]!= ' ') {
/* c ? est un oprateur */
nb2 = Depiler ( p ) ;
nb1 = Depiler ( p ) ;
/* attention , c ' est une pile */
switch ( exp [ k ]) {
case '+ ': Empiler (p , nb1 + nb2 ) ; break ;
case ' - ': Empiler (p , nb1 - nb2 ) ; break ;
case '* ': Empiler (p , nb1 * nb2 ) ; break ;
case '/ ': Empiler (p , nb1 / nb2 ) ; break ;
}
}
k ++;
}
}
/* le resultat est en haut de la pile */
return Depiler ( p ) ;
}
/*
Principe :
- Les oprateurs utiliss sont tous binaires (2 oprandes )
- On a en entre l ' expression en notation polonaise , les items
sont spars
par un ou plusieurs blanc ( s )
- On lit l ' expression de gauche droite :
- si c ' est un nombre , on l ' empile
- si c ' est un oprateur , on dpile 2 nombres et on empile le
rsultat de l ' opration .
Exemple : en entre on a 5 9 8 + 4 6 * * 7 + *
5 9 8 -> 5 17 -> 5 17 4 6 -> 5 17 24 -> 5 408 -> 5 408 7 -> 5 415
-> 2075
*/

Exercice 6. Files :

1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6

# define MAX_F

typedef struct file_ {

int
tab [ MAX_F ];
int tete ;
int queue ;
} file ;
void creerfile ( file * f , int max ) ;
int filevide ( file * f ) ;
int filepleine ( file * f ) ;
void enfiler ( file *f , int x ) ;
int defiler ( file * f ) ;
void supprimerfile ( file * f ) ;
void creerfile ( file * f , int max ) {
if ( max <= 0)
{
printf ( " erreur : creerfile : la taille doit etre positive \ n " ) ;
return ;
}

f = ( file *) malloc ( max * sizeof ( struct file ) ) ;

f - > tete = 0;
f - > queue = 0;

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

}
/* --------------------------------------------------- */
int filevide ( file * f ) {
return (f - > tete == f - > queue )
}
/* --------------------------------------------------- */
int filepleine ( file * f ) {
if (f - > tete == (f - > queue +1) % MAX_F ) return 1;
else return 0;
}
/* --------------------------------------------------- */
void enfiler ( file *f , int x ) {
if ( filepleine ( f ) ) {
printf ( " erreur : emfiler : la file est pleine \ n " ) ;
return ;
}

30
31
32
33
34
35
36
37
38
39
40
41

f - > tab [f - > queue ] = x ;

if (f - > queue == ( MAX_F -1) ) f - > queue = 0;
else f - > queue = f - > queue + 1;

/* --------------------------------------------------- */
int defiler ( file * f ) {
int x ;
if ( filevide ( f ) ) {
printf ( " erreur : defiler : la file est vide \ n " ) ;
return 0;

42
43
44
45
46
47
48
49
50
51
52

}
x = f - > tab [ f - > tete ];
if (f - > tete == ( MAX_F -1) ) f - > tete = 0;
else f - > tete = f - > tete + 1;
return x ;

/* --------------------------------------------------- */
void supprimerfile ( file * f ) {
free ( f ) ;
}