1 Correction TD 3

2 Exercice 1

#include <stdio.h>

typedef struct pst {

int t[100];

int taille;

}pile;

void init(pile *p)

p->taille=0;

int est_vide(pile p)

if (p.taille==0)

return (1);

else

return (0);

}
void empiler (pile*p, int e)

if (p->taille==100)

printf ("la pile est pleine");

else

p->t[p->taille]=e;

(p->taille)++;

void depiler (pile*p)

if (p->taille==0)

printf ("la pile est vide");

else

(p->taille)--;

int sommet (pile p)

if (est_vide(p))

printf ("erreur pile vide"); return -32000; }

/*on suppose que le nombre -32000 n’est jamais

utilisé dans la pile et qu’il appartient à element */

else
 return p.t[(p.taille)-1];

void affiche (pile p)

while (!est_vide(p))

printf ("%d ", p.t[(p.taille)-1]);

depiler (&p);

void pairs_impairs (pile*p, pile*p1, pile p2)

//pile p2;

while (!est_vide(*p))

if ((p->t[(p->taille)-1])%2==0)

empiler(p1,p->t[(p->taille)-1]);

depiler (p);

else

empiler(&p2,p->t[(p->taille)-1]);

depiler (p);

while (!est_vide(p2))

{
 empiler(p1,p2.t[(p2.taille)-1]);

depiler (&p2);

int main()

pile p,p1,p2;

init (&p);

init(&p1);

init(&p2);

empiler (&p, 1);

empiler (&p, 2);

empiler (&p, 4);

empiler (&p, 9);

affiche (p);

pairs_impairs(&p,&p1,p2);

affiche (p1);

Exercice 2

Concernant la première question, on va empiler les caractères ‘(‘ dans la pile p et on va dépiler la
pile p, une fois, on a rencontré le caractère ‘)’. Si à la fin du traitement la pile p est non vide alors,
notre chaine n’est pas bien balancée. Sinon, concernant la deuxième question, on empiler la position
de la parenthèse ‘(‘ trouvée et on dépile la pile pos, une fois, on a trouvée une ‘)’. Si à la fin du
traitement la pile « pos » reste pleine alors la position de la parenthèse qui pose problème est celle
stockée au sommet de la pile « pos ».

Int chaine_balancee(char *ch)

Pile p, pos ;
For (int i=0 ; i<strlen(ch) ; i++)

If (ch [i] ==’(‘ )

Empiler (p, ch[i]); //empiler (pos, i);

Else

If (ch[i] == ’)’ )

if (!est_vide(p))

Dépiler (p); //dépiler (pos);

Else

Return 0; //return (i);

If (!est_vide(p))

Return 0; // return (sommet(p));

Else

Return 1; //return (-1);

3 Exercice 3

#include <stdio.h>

#define Taille 100

#define max (Taille+1)

struct stfile
{

int t[Taille];

int tete;

int queue;

};

typedef struct stfile file;

void init (file *f)

f->tete=0;

f->queue=0;

int vide (file f)

if(f.tete==f.queue)

return 1;

else

return 0;

void enfiler (file*f, int e)

if ((f->tete-f->queue==1)||(f->tete==0 && f->queue==Taille))

{
 printf ("la file est pleine");

else

f->t[f->queue]=e;

f->queue=(f->queue+1)%max;

void defiler (file*f)

if (vide(*f)==0)

f->tete=(f->tete +1)%max;

void affiche (file f)

if (vide(f)==0)

for (int i=f.tete; i<f.queue;i++)

printf ("lelement est %d \n", f.t[i]);

}
void pairs_impairs(file * f1, file* f2)

file f3;

while (vide(*f1)==0)

if((f1->t[f1->tete])%2==0)

enfiler(f2, f1->t[f1->tete]);

defiler(f1);

else

enfiler(&f3, f1->t[f1->tete]);

defiler(f1);

/*affiche (*f1);

printf ("******\n");

affiche (*f2);

printf ("******\n");
 affiche (f3);*/

while ((vide(f3)==0))

enfiler(f2, f3.t[f3.tete]);

defiler(&f3);

void pairsInverse(file f1, file*f2)

File f3; int n=0;

While (!vide(f1))

If (f1.t[tete]%2==0)

{Enfiler (f3, f1.t[f1.tete]) ;

Defiler (f1) ;

N++ ;

While (n !=0)

Int i=n ;

While (i!=1)

Enfiler (f3, f3.t[f3.tete]);

Defiler (f3) ;
i-- ;

Enfiler (f2, f3.t[f3.tete]);

Defiler(f3) ;}

n-- ;

int main()

file ff;

init(&ff);

file ft;

init(&ft);

enfiler(&ff, 1);

enfiler(&ff, 3);

enfiler(&ff, 6);

enfiler(&ff, 9);

enfiler(&ff, 8);

affiche(ff);

//defiler (&ff);

//printf ("le resultat de la file apres defilementest \n");

//affiche(ff);
 printf ("le resultat de la file apres execution est \n");

//pairs_impairs(&ff, &ft);

pairsInverse(ff,&ft);

affiche (ft);

return 0;

4 Exercice 4

Remarque: concernant cet exercice on va supposer que les listes ne contiennent pas des doublons

#include <stdio.h>

#include <stdlib.h>

struct noeud{

int val;

struct noeud* suivant;

};

typedef struct noeud* liste;

liste ajouttete(liste*l, int e)

liste new=(struct noeud*)malloc (sizeof(struct noeud));

 new->val=e;

if (*l == NULL)

new->suivant=NULL;

*l=new;

else

new->suivant=*l;

*l=new;

return (*l);

void affiche(liste l)

liste q=l;

while (q!=NULL)

printf (" lelement de la liste est %d \n", q->val);

q=q->suivant;

//printf("\n");
}

liste soustraction (liste l1, liste l2, liste*la)

if (!l1)

*la=NULL;

if(!l2)

*la=l1;

liste p=l1;

while (p!=NULL)

int existe=0;

liste pp=l2;

while(pp!=NULL)

if(pp->val==p->val)

existe=1;

pp=NULL;

}
 else

pp=pp->suivant;

if(existe==0)

*la=ajouttete(la, p->val);

p=p->suivant;

return (*la);

liste addition (liste l1, liste l2, liste * lb)

Liste p=*lb=l1;

while (p->suivant)

p=p->suivant;

P= soustraction ( l1, l2, &p) ;

 return (*lb);

int main()

liste p=NULL;

liste res=NULL;

liste ad=NULL;

// liste v=NULL;

p=ajouttete(&p, 8);

p=ajouttete(&p, 2);

p=ajouttete(&p, 1);

affiche (p);

liste r=NULL;

r=ajouttete(&r, 3);

r=ajouttete(&r, 2);

r=ajouttete(&r, 9);

printf("********\n");

affiche(r);

res=soustraction(p, r,&res);
 printf ("le resultat de la soustraction est\n");

affiche (res);

ad=addition(p, r, &ad);

printf ("le resultat de laddition est\n");

affiche (ad);

return 0;

5 Exercice 5

En récursif :

Liste diffsym(liste A,B)

liste C=NULL;

if ((!A)&&(!B))

return(C)

if((!B)|| (A &&(A->val val))

C=diffsym(A->suiv, B);

C=insere(A->val;C);

return(C);

if((!A)|| (B && (A->val >B->val))

{
C=diffsym(A, B->suiv);

C=insere(B->val;C);

return(C);

C=diffsym(A->suiv, B->suiv);

return(C);

En itératif :

Liste diffsym(liste A,B)

liste C=NULL, fc=NULL;

while (A&&B)

if (A->val val)

if (fc)

fc->suiv=insere(A->val,NULL);

fc=fc->suiv;

else

fc=C=insere(A->val,NULL);

A=A->suiv;

else if (A->val >B->val)

if (fc) {
fc->suiv=insere(B->val,NULL);

fc=fc->suiv;}

else {

fc=C=insere(B->val,NULL);

B=B->suiv;}

Else { A=A->suiv; B=B->suiv;}

if (!A)

for (;B;B=B->suiv){

{if (fc) {fc->suiv=insere(B->val,0); fc=fc->suiv;}

Else { fc=C=insere(B->val,NULL);}

else if (!B) for (;A;A=A->suiv)

{ {if (fc) {fc->suiv=insere(A->val,NULL); fc=fc->suiv;}

else fc=C=insere(A->val,NULL);

return(C);}

La function “insere” est définie comme suit:

Liste insere (int x ; liste L)

{p=(liste)malloc(sizeof(maillon)) ;

p->val=x ;

p->suiv=L ;

return(p) }