EX 1 :

Procedure Empiler(P1,P2: Pile)

var

P3 : Pile
x*:entier

Debut

tant que (non(Pile_vide(P1)) faire

depiler(x,P1)
Si(*x mod 2 = 0)
empiler(*x,P2)
Si(P1 mod 2 <> 0)
empiler(*x,P3)
fin si

fin tant que

tant que (non(Pile_vide(P3)) faire

depiler(x,P3)
empiler(*x,P2)

fin tantque

Fin

-----------------------------------------------------------------------------------

EX 2 :

procedure palindrome(P:Pile)
var
F : File
P1,P2 : Pile
x* : caractere
comp : entier

Debut

P1 <-- P
tant que (non(Pile_vide(P1)) faire

depiler(x,P1)
emfiler(*x,F)

fin tantque

tant que (non(File_vide(F)) faire

defiler(x,F)
empiler(*x,P2)

fin tantque

comp <-- 1
tant que ((comp=1)et(non(Pile_vide(P1)et(non(Pile_vide(P2)) faire

si(P1<>P2) alors
comp <-- 0
fin si
depiler(x,P1)
depiler(x,P2)

fin tantque

si(comp=1)alors
ecrire("le mot est palindrome")
sinon
ecrire("le mot n'est pas palindrome")
fin si

Fin

-----------------------------------------------------------------------------------

EX 3 :
1)fonction copier (P : Pile) : File
var
F:File
x*:entier
debut
depiler(x,P)
enfiler(*x,F)
copier <-- F
fin
2)procédure inverserPile (P : Pile)
F:File
x*:entier
debut
tantque (non(pile_vide(P)))
depiler(x,P)
enfiler(*x,F)
fin tantque

tantque (non(File_vide(F)))
defiler(x,F)
enpiler(*x,P)
fin tantque

fin

3)procédure inverserFile (F : File)

-----------------------------------------------------------------------------------

EX 4 :

Procedure Emfiler(F1,F2: File)

var
F3 : File
x*:entier

Debut

tant que (non(File_vide(F1)) faire

deFiler(x,F1)
Si(*x mod 2 = 0)
emfiler(*x,F2)
Si(*x mod 2 <> 0)
emfiler(*x,P3)
fin si

fin tant que

tant que (non(File_vide(F3)) faire

defiler(x,F3)
emfiler(*x,F2)

fin tantque

Fin

-----------------------------------------------------------------------------------

EX 5 :

1)
type
support=Enregistrement
nom:chaine[30]
panier:entier
coeff:entier
rev:entier
finEnregistrement

Cellule=Enregistrement
val:support
suivant: *Cellule
finEnregistrement

LSC:*Cellule
Pile=LSC
var
P:Pile

2)
fonction ajouter(S:support,P:Pile) : Pile

Var element : LSC

Début
element <-- allouer(taille(Cellule))
*element.val <-- S
*element.Suivant <-- P
P <-- element
ajouter <-- P
Fin

3)
fonction retirer(x:entier;P:Pile) : Pile
Var
P1: Pile
pos: entier
y*: support
Début
pos <-- 1
Si (Pile_vide(P) = faux) Alors
si(pos<>x)alors
depiler(y,P)
empiler(*y,P1)
sinon
depiler(y,P)
FinSi
FinSi

retirer <-- P1
Fin

4)

5)
fonction Rev_Nonrev(P:Pile) : Pile
var
*x: support
P1,P2:Pile

Debut

tant que (non(Pile_vide(P)) faire

depiler(x,P)
Si(*x.rev = 1)
empiler(*x,P1)
Si(*x.rev = 0)
empiler(*x,P2)
fin si

fin tant que

tant que (non(Pile_vide(P2)) faire

depiler(x,P2)
empiler(*x,P1)

fin tantque

Rev_Nonrev <-- P1

Fin

6)
fonction trier(P:Pile) : Pile
-----------------------------------------------------------------------------------

EX 6 :

-----------------------------------------------------------------------------------

EX 7 :

1)
fonction Enfiler( F : File ; X : citoyen ) : File
Var
element : LS
Début

element ← Allouer(taille(Cellule))
*element.Val ← X
*element.Suivant ← NULL
Si (File_vide(F)) Alors
F.Sommet ← element
Sinon
(*F.Queue).Suivant← element
Fin Si
F.Queue ← element

Enfiler <-- F

Fin

2)
procedure servir(F:FILE)

3)
procedure compter(F:File,nb1*:entier,nb2*:entier)
var
F1:File
x*:citoyen
debut

(*nb1)<--0
(*nb2)<--0
F1<--F
tant que(non(File_vide(F1))) faire
defiler(x,F1)
si((*x).type=1)alors
(*nb1)<--(*nb1)+1
sinon
(*nb2)<--(*nb2)+1
finsi
fin tant que

Fin