!

" #

$%&

'!( -

' () & (' * ( () &+ %

( () &+ %

Anne Universitaire : 2008 2009

!"

#"

e fascicule des travaux dirigs dalgorithmique et structures de donnes II est

lintention des tudiants de la premire anne en Licence en Informatique Applique
la Gestion de la Facult des Sciences Juridiques, conomique et de Gestion de
Jendouba. Il aborde brivement les thmes les plus classiques et les plus utiliss en informatique :
les enregistrements, les fichiers, la rcursivit, les listes chaines, les piles, les files et les arbres
binaires de recherche.
Le fascicule comporte 5 TD avec leurs corrections qui sont rparties comme suit :
TD1 : Les enregistrements et les fichiers
TD2 : La rcursivit
TD3 : Les listes chaines
TD4 : Les piles et les files
TD5 : Les arbres binaires de recherche
Une fois que ltudiant obtenue une connaissance suffisante sur la manipulation des types
simples, dans ce fascicule nous dbuterons par un TD1 qui est consacr pour la manipulation des
types complexes(les enregistrements), et sur les fichiers squentiels. Ltudiant sera capable la
fin du TD1 manipuler les fichiers.
Dans le TD2, nous traiterons les sous programmes rcursifs, nous allons voir de plus prs le
mcanisme de transformation dun programme itrative en un programme rcursif. Ltudiant
dans ce TD doit savoir excuter la main en utilisant une pile.
Aprs avoir traiter les programmes en version rcursifs, le TD3 sera sur lallocation dynamique
aprs avoir vu au part avant lallocation statique. Dans ce TD nous traiterons les listes chaines que
ce soit simple, double ou circulaire. Ltudiant doit apprendre crer une liste, la parcourir et
enfin savoir comment supprimer un lment.
Le TD4 est une suite du prcdent, vu quil sagit dune liste chaine avec des stratgies daccs,
pour les piles, ils utilisent la stratgie (Last In First Out) et pour les files (First In First out). Nous
dfinirons les diffrents sous programmes qui seront utiles pour manipuler ces derniers.
A la fin nous entamerons le TD5 qui sera consacr pour la manipulation des arbres binaires de
recherche. Nous allons traiter dans celui l les diffrents algorithmes avancs : la rotation, la
fusion, la vrification dun arbre sil est parfait, dgnr,
Enfin, nous esprons que le prsent ouvrage aura le mrite dtre un bon support pdagogique
pour lenseignant et un document permettant une concrtisation exprimentale pour ltudiant.

Page 1 sur 53

$ %"

$ &'()

$
%

+ ,

-........................................................................................ /

+ ............................................................................................................................ 0
+ 1,!

-............................................................................................................................ 1

+1.......................................................................................................................... 2
+/,

-.............................................................................................................. 13

+/.......................................................................................................................... 11
+ 2,

-............................................................................................................... //

+2.......................................................................................................................... /2
+ 0,

#
&& ' !

$ -................................................................................................. /4

+0.......................................................................................................................... 23
5 ".................................................................................................................................... 0/

Page 2 sur 53

(
%
#
)

:
:

<
<

#$
#$

;"
*

< 133=>133? @ )

< ! $ %"
"!"5
< ! $ &'() %

+ ,

'*6

"7"!#

#" 8+

Crer un enregistrement nomm "

et un
.

qui est caractris par un

, un

On vous demande de saisir 10 tudiants, les ranger dans un tableau puis les afficher.
"7"!#

#" 8+1

On reprend lexercice prcdent mais on rajoute en plus pour chaque tudiant ses deux
notes. On vous demande de crer le nouvel enregistrement nomm 8
qui est
caractris par NoteCc (Note de contrle continu) et NoteEx (Note dexamen).
Modifier lenregistrement "
lenregistrement 8
.

afin quelle puisse tre en relation avec

On vous demande de crer :

Une procdure de saisi des tudiants ainsi leurs notes.
Une procdure daffiche des tudiants avec leurs notes.
Une fonction qui renvoie ltudiant qui a eu la meilleure note dexamen.
Une fonction qui renvoie la moyenne gnrale de la classe.

0.3

0.7

Afficher la meilleure note dexamen et la moyenne gnrale de la classe.

9crire le programme principal faisant appel aux diffrents sous programmes.
"7"!#

#" 8+/

On souhaite mmoriser des noms des personnes dans un fichier nomm

On vous demande alors de crer les sous programmes qui suivent :

Une procdure de cration du fichier qui contient les noms des personnes.
Une procdure daffichage des noms de personnes.
Une fonction qui permet de chercher un nom pass en argument et qui renvoie
vrai si ce dernier est existant et faux sinon.
Une procdure qui copie les noms sans compter le nom pass en paramtre.
9crire le programme principal faisant appel aux diffrents sous programmes.
Page 3 sur 53

"7"!#

#" 8+2

On souhaite mmoriser les tudiants de la facult ainsi que leurs notes dans un fichier
nomm $ .
. Un tudiant est caractris par un
, un
et un
. Chaque tudiant aura deux notes : une note de contrle contenu et une note
dexamen.
<
. Crer les enregistrements ncessaires pour laborer ce programme.
1. 9crire une procdure permettant de saisir les notes associes un tudiant donn
en paramtre.
/. 9crire une procdure permettant de crer le fichier des tudiants.
2. 9crire une procdure qui permet de copier les tudiants qui ont eu une moyenne
suprieure ou gale 10 du fichier $ .
dans un tableau des tudiants.
0. 9crire une procdure qui permet de trier un tableau dtudiants dans lordre
dcroissant selon leurs moyennes.
A. 9crire une procdure qui permet de crer le fichier nomm B
.
qui
contiendra les tudiants qui sont russt, tri dans lordre dcroissant.
4. 9crire une procdure qui permet dafficher le contenu du fichier
.
.
=. 9crire le programme principal qui fait appel aux diffrents sous programmes.

Page 4 sur 53

#
"7"!#

#" 8+

Algorithme GesEtud
Type
Etudiant : Enregistrement
Ident : Entier
Nom : chaine[30]
Prnom : chaine[20]
Fin Etudiant
TAB : Tableau de 10 Etudiant
Var
ET : TAB
n : Entier
Procdure Remplissage(m : Entier ; var T : TAB)
Var
i : Entier
Dbut
Pour i de 1 m faire
Ecrire("Etudiant n",i," :")
Ecrire("Identifiant : "),Lire(T[i].Ident)
Ecrire("Nom : "),Lire(T[i].Nom)
Ecrire("Prnom : "),Lire(T[i].Prnom)
Fin Pour
Fin
Procdure Affichage(m : Entier ; var T : TAB)
Var
i : Entier
Dbut
Ecrire("Identifiant
Nom
Prnom : ")
Ecrire("*************************************************")
Pour i de 1 n faire
Ecrire(T[i].Ident," ",Lire(T[i].Nom," ",T[i].Prnom)
Fin Pour
Fin

Dbut
n
10
Remplissage(n,ET)
Affichage(n,ET)
Fin

Page 5 sur 53

"7"!#

#" 8+1

Algorithme GesEtud
Type
Notes : Enregistrement
noteCc : Rel
noteEx : Rel
Fin Notes
Etudiant : Enregistrement
Ident : Entier
Nom : chaine[30]
Prnom : chaine[20]
Note : Notes
Fin Etudiant
TAB : Tableau de 10 Etudiant
Var
ET : TAB
n : Entier
Procdure SaisiNotes(var E : Etudiant)
Var
noteEntrer : Rel
Dbut
Rpter
Ecrire("Note contrle contenu : "),Lire(noteEntrer)
Jusqu noteEntrer 0 ET noteEntrer 20
E.Note.NoteCc
noteEnter
Rpter
Ecrire("Note examen : "), Lire(noteEntrer)
Jusqu noteEntrer 0 ET noteEntrer 20
E.Note.NoteEx
noteEnter
Fin
Procdure Remplissage(m : Entier ; var T : TAB)
Var
i : Entier
Dbut
Pour i de 1 m faire
Ecrire("Etudiant n",i," :")
Ecrire("Identifiant : "),Lire(T[i].Ident)
Ecrire("Nom : "),Lire(T[i].Nom)
Ecrire("Prnom : "),Lire(T[i].Prnom)
SaisiNotes(T[i])
Fin Pour
Fin

Page 6 sur 53

Procdure AfficheNotes(E : Etudiant)

Dbut
Ecrire("Note Contle Contenu
Note Examen ")
Ecrire("************************************")
Ecrire(E.Note.NoteCc,"
",E.Note.NoteEx)
Fin
Procdure Affichage(m : Entier ; T : TAB)
Var
i : Entier
Dbut
Ecrire("Identifiant
Nom
Prnom : ")
Ecrire("*************************************************")
Pour i de 1 n faire
Ecrire(T[i].Ident," ",Lire(T[i].Nom," ",T[i].Prnom)
AfficheNotes(T[i])
Fin Pour
Fin
Fonction MeilleureNote(m : Entier ; T : TAB) : Rel
Var
i : Entier
NoteMax : Rel
Dbut
NoteMax
T[1].Note.NoteEx
Pour i de 2 m Faire
Si T[i].Note.NoteEx > NoteMax Alors
NoteMax
T[i].Note.NoteEx
Fin Si
Fin Pour
MeilleureNote
NoteMax
Fin
Fonction MoyenneGnrale(m : Entier ; T : TAB) : Rel
Var
i : Entier
som : Rel
Dbut
som
0
Pour i de 2 m Faire
som
som + 0.3 x T[i].Note.noteCc + 0.7 x T[i].Note.noteEx
Fin Pour
MoyenneGnrale
som / m
Fin
Dbut
n
10
Remplissage(n,ET)
Affichage(n,ET)
Ecrire("Meilleur note examen :", MeilleureNote(n,ET),
" Moyenne gnrale de la classe :", MoyenneGnrale(n,ET))
Fin
Page 7 sur 53

"7"!#

#" 8+/

Algorithme TraiTFichNom
Type
Nom : chaine[30]
FichNoms : Fichier de Nom
Var
F1,F2 : FichNoms
Procdure Cration(Var fn : FichNoms)
Var
n : Nom
rep : caractre
Dbut
Ouvrir(fn,E)
rep
O
Tant que MAJUS(rep) = O Faire
Ecrire(Nom : ), Lire(n)
Ecrire(fn,n)
Ecrire(Voulez*vous ajouter un autre nom (O/N) : )
Lire(rep)
Fin Tant que
Fermer(fn)
Fin
Procdure Affichage(fn : FichNoms)
var
n : Nom
Dbut
Ouvrir(fn,L)
Lire(fn,n)
Tant que NON(FinDeFichier(fn)) Faire
Ecrire(n)
Lire(fn,n)
Fin Tant que
Fermer(fn)
Fin
Fonction Recherche(x : Nom ; fn : FichNoms) : Boolen
var
n : Nom
Trouve : Boolen
Dbut
Ouvrir(fn,L)
Lire(fn,n)
Trouve
(n = x)
Tant que Trouve=faux ET NON(FinDeFichier(fn)) Faire
Lire(fn,n)
Trouve
(n = x)
Fin Tant que
Si FinDeFichier(fn) Alors
Recherche
faux
Sinon
Recherche
vrai
Fin Si
Fermer(fn)
Fin
Page 8 sur 53

Procdure Copier(x : Nom ; fn : FichNoms ; var ft : FichNoms)

var
n : Nom
Dbut
Ouvrir(fn,L)
Ouvrir(ft,E)
Lire(fn,n)
Tant que n x ET NON(FinDeFichier(fn)) Faire
Ecrire(ft,n)
Lire(fn,n)
Fin Tant que
Si NON(FinDeFichier(fn)) Alors
Lire(fn,n)
Tant que NON(FinDeFichier(fn)) Faire
Ecrire(ft,n)
Lire(fn,n)
Fin Tant que
Fin Si
Fermer(fn)
Fermer(ft)
Fin

Dbut
Cration(F1)
Affichage(F1)
Si Recherche("Riadh",F1) Alors
Ecrire("Riadh est existant dans le fichier")
Sinon
Ecrire("Riadh est non existant dans le fichier")
Fin Si
Copier("Riadh",F1,F2)
Affichage(F2)
Fin

"7"!#

#" 8+2

Algorithme GesEtudFichier
Type
Notes : Enregistrement
noteCc : Rel
noteEx : Rel
Fin Notes
Etudiant : Enregistrement
Ident : Entier
Nom : chaine[30]
Prnom : chaine[20]
Note : Notes
Fin Etudiant
TAB : Tableau de 100 Etudiant
FichEtud : Fichier de Etudiant

Page 9 sur 53

Var
Fe,Fr : FichEtud
Procdure SaisiNotes(var E : Etudiant)
Var
noteEntrer : Rel
Dbut
Rpter
Ecrire("Note contrle contenu : "),Lire(noteEntrer)
Jusqu noteEntrer 0 ET noteEntrer 20
E.Note.NoteCc
noteEnter
Rpter
Ecrire("Note examen : "), Lire(noteEntrer)
Jusqu noteEntrer 0 ET noteEntrer 20
E.Note.NoteEx
noteEnter
Fin
Procdure Cration(var fn : FichEtud )
Var
Et : Etudiant
rep : caractre
Dbut
Ouvrir(fn,E)
rep
O
Tant que MAJUS(rep) = O Faire
Ecrire("Identifiant : "),Lire(Et.Ident)
Ecrire("Nom : "),Lire(Et.Nom)
Ecrire("Prnom : "),Lire(Et.Prnom)
SaisiNotes(Et)
Ecrire(fn,Et)
Ecrire(Voulez*vous ajouter un autre nom (O/N) : )
Lire(rep)
Fin Tant que
Fermer(fn)
Fin
Procdure CopierDansTab(fn :FichEtud; var n:Entier ;var T : TAB )
var
Et : Etudiant
Moy : Rel
Dbut
Ouvrir(fn,L)
Lire(fn,Et)
n
0
Tant que NON(FinDeFichier(fn)) Faire
Moy
0.3 x Et.Note.noteCc + 0.7 x Et.Note.noteEx
Si Moy 10 Alors
n
n + 1
T[n]
Et
Fin Si
Lire(fn,Et)
Fin Tant que
Fermer(fn)
Fin

Page 10 sur 53

Procdure TriBulle( n : Entier ; var T :TAB)

Var
i : Entier
aux : Etudiant
rep : Boolen
moy 1,moy2: Rel
Dbut
Rpter
rep
faux
Pour i de 1 n Faire
moy1
0.3 x T[i].Note.noteCc + 0.7 x T[i]
moy2
0.3 x T[i+1].Note.noteCc + 0.7 x T[i+1]
Si moy1 < moy2 Alors
aux
T[i]
T[i]
T[i+1]
T[i+1]
aux
rep
vrai
Fin Si
Fin Pour
n
n + 1
Jusqu rep = faux OU n =1
Fin
Procdure Rsultat(fn :FichEtud; var fr : FichEtud)
Var
i,n : Entier
T : TAB
Dbut
CopierDansTab(fn,n,T)
TriBulle(n,T)
Ouvrir(fr,E)
Pour i de 1 n Faire
Ecrire(fr,T[i])
Fin Pour
Fermer(fr)
Fin
Procdure Affichage(fr : FichNoms)
var
Et : Etudiant
Moy : Rel
Dbut
Ouvrir(fr,L)
Lire(fr,Et)
Tant que NON(FinDeFichier(fr)) Faire
Moy
0.3 x Et.Note.noteCc + 0.7 x Et.Note.noteEx
Ecrire(Et.Ident, ,Et.Nom, ,Et.Prnom, ,Moy)
Lire(fr,Et)
Fin Tant que
Fermer(fr)
Fin

Dbut
Cration(Fn)
Affichage(Fn)
Rsultat(Fn,Fr)
Affichage(Fr)
Fin

Page 11 sur 53

(
%
#
)

:
:

< 133=>133? @ )

<
<

#$
#$

;"
*

< ! $ %"
"!"5
< ! $ &'() %

+ 1,!
-

,!

'*6

"7"!#

#" 8+

9crire une fonction rcursive qui retourn la somme des chiffres dun entier N donn.
( 123 == > 1 + 2 + 3 = 6 )
"7"!#

#" 8+1

9crire une fonction rcursive qui calcul la factorielle dun entier N positif.
( 5 ! = 5 x 4 x 3 x 2 x 1 = 120)
"7"!#

#" 8+/

9crire une fonction rcursive qui permet de dterminer si un entier N saisi au clavier est
premier ou pas. (Un nombre premier nest divisible que par 1 ou lui mme).
"7"!#

#" 8+2

9crire une procdure rcursive qui permet dinverser une chaine de caractres sans utiliser
une chaine temporaire.
information
"7"!#

noitamrofni

#" 8+0

9crire une fonction rcursive qui permet de vrifier si deux chaines s1 et s2 sont
anagrammes ou non.
s1 et s2 sont anagrammes sils se composent de mme lettre.
s1 = "chien" ; s2 = "niche"
"7"!#

vrai

#" 8+A

9crire une fonction rcursive qui permet de vrifier si un mot planch en paramtre est
palindrome ou non.
mot = "aziza"

vrai ;

mot = "alga"

Page 12 sur 53

faux

"7"!#

#" 8+4

9crire une fonction rcursive nomme ! $C

qui permet de chercher un entier
x dans un tableau T de n entiers selon le principe de la recherche squentielle.
9crire une fonction rcursive nomme ! $C
qui permet de chercher un entier
x dans un tableau T de n entiers selon le principe de la recherche dichotomique.
"7"!#

#" 8+=

9crire une procdure rcursive indirecte nomm

C&
T de n entiers. Utiliser les deux procdures ci dessous :
,
;D<"
, ; <"
E

qui permet de trier un tableau

<&

<

&-

8& :
elle est utilise pour renvoy sil ya eu une permutation au cours du parcours du
tableau.
"7"!#

#" 8+?

9crire une procdure rcursive nomme Anagramme qui permet dafficher tous les
anagramme dune chaine ch.
NB : Utiliser une permutation circulaire pour rsoudre ce problme.
ch="iag"
Les anagrammes de iag sont :
1)
2)
3)
4)
5)
6)

"7"!#

aig
agi
gai
gia
iga
iag

#" 8+

9crire un programme rcursif permettant de dessiner une pyramide dtoiles selon un

entier n donn, avec n un nombre impair.
n=9

Page 13 sur 53

#
"7"!#

+1

#" 8+

Fonction Somme(n :Entier) : Entier

Var
s : Entier
Dbut
Si n>0 Alors
s s + n MOD 10
Somme
Somme(n DIV 10)
Fin Si
Somme
s
Fin

"7"!#

#" 8+1

Fonction Factorielle (n :Entier) : Entier

Var
fac : Entier
Dbut
Si n>0 Alors
fac
fac + n
Factorielle
Factorielle(n * 1)
Fin Si
Factorielle fac
Fin

"7"!#

#" 8+/

Fonction Premier (d, n :Entier) : Entier

Dbut
Si d ((N DIV 2)+1) Alors
Si n MOD d 0 Alors
Premier
Premier(d+1, n)
Sinon
Premier
vrai
Fin Si
Sinon
Premier
faux
Fin Si
Fin

Page 14 sur 53

"7"!#

#" 8+2

Procdure Inverse (var ch : chaine)

Var
c : caractre
Dbut
Si ch = "" Alors
Inverse
""
Sinon
c
ch[LONG(ch)]
Effacer(ch,long(ch),1)
Inverse(ch)
ch
c + ch
Fin Si
Fin

"7"!#

!!

"

!!
!! #
!! $
!!

#" 8+0

Fonction Anagramme (var s1, s2 : chaine) : Boolen

Var
c : caractre
Dbut
Si LONG(s1) LONG(s2)Alors
Anagramme
faux
Sinon
Si LONG(s1) = LONG(s2) = 0 Alors
Anagramme
vrai
Sinon
p = POS(s1[1],s2) !!
%
!!
!!

&

Si p = 0 Alors
Anagramme
faux
Sinon
EFFACER(s1,1,1) !!#
%
EFFACER(s2,p,1) !!#
Anagramme
Angramme(s1,s2)
Fin Si
Fin Si
Fin Si
Fin

Page 15 sur 53

%
&

"7"!#

#" 8+A

Function Palindrome (mot : chaine) : Boolen

Var
c : caractre
Dbut
Si mot= "" Alors
!!
Palindrome
Vrai
Sinon
Si mot[1] = mot[LONG(mot)] Alors
EFFACER(mot,1,1)
!!#
EFFACER(mot,LONG(mot),1)
!!#
Palindrome
Palindrome(mot)
Sinon
Palindrome
faux
Fin Si
Fin Si
Fin

"7"!#

#" 8+4

Function Rech_seq(i, n, x : Entier ; T : TAB) : Boolen

Dbut
Si i n Alors
Si T[i] = x Alors
Rech_seq
Vrai
Sinon
Rech_seq
Rech_seq(i+1,n,x,T)
Fin Si
Sinon
Rech_seq
Faux
Fin Si
Fin
Function Rech_dico(g, d, x : Entier ; T : TAB) : Boolen
Var
m : Entier
Dbut
Si g>d Alors
Rech_dico
faux
Sinon
m
(d + g) DIV 2
Si T[m] = x Alors
Rech_dico
Vrai
Sinon Si T[m]>x Alors
Rech_dico
Rech_dico(g,m;1,x,T)
Sinon
Rech_dico
Rech_dico(m+1,d,x,T)
Fin Si
Fin Si
Fin
Page 16 sur 53

"

"7"!#

#" 8+=

Procdure Permuter(var x, y : Entier)

Var
Aux : Entier
Dbut
aux
x
x
y
y
aux
Fin

Procdure Parcours(i,n :Entier ; var rep : Boolen ; var T :TAB)

Dbut
Si i<n Alors
Si T[i] >T[i+1] Alors
Permuter(T[i],T[i+1])
rep
Vrai
Fin Si
Fin Si
Fin
Procdure TriBulle(n : Entier ;Perm : Boolen var T :TAB)
Var
Perm : Boolen
Dbut
!!
!!

'%
"

Si ((n>1) ET (Perm = vrai)) Alors

Perm
Faux
Parcours(1,n,Perm,T)
TriBulle(n*1,Perm,T)
Fin Si
Fin

"7"!#

#" 8+?

Procdure PermutCirc(var ch :chaine)

Dbut
!!

Si LONG(ch)>1 Alors
!!

Ch
Fin Si
Fin

ch[LONG(ch)] + SOUS;CHAINE(ch,2,LONG(ch)*1)

Page 17 sur 53

Procdure Anagramme(s : chaine ; c : Entier ; var l : Entier)

Var
i : Entier
tete, queue : chaine
Dbut
Pour i de 1 LONG(s) * c
tete
SOUS;CHAINE(s, 1, c)
queue
SOUS;CHAINE(s, c+1, LONG(s)*c)
s = tete + PermutCirc(queue)
Si c = LONG(s) * 1 Alors
l
l + 1
Ecrire(l,")",s)
Sinon
Anagramme(s, c + 1, l)
Fin Si
Fin Pour
Fin

F
!
"#
$"
%"
& &
'( (
$
%
" )*#

1 2 0,

.
# !

- + (%

& ++ #1

"#
$"
%"#
& &
'( (
$
% # " )*#

& ++ #1

- + (%

+ !
"#
$"
+ - + (%
%"+
& &
'( (
& &
$
% + " )*# &
- /% +")*# &

/,

1 / /,
"#
$"
%"#
& &
'( (
$
% # " )*#

(,
+ #!

"#
$"
%"+
'( (
$

- +
0,

Page 18 sur 53

+ - + (%

"7"!#
.

#" 8+

Algorithme Pyramide
Var
n : Entier

!!

Fonction Saisie() : Entier

Var
m : Entier
Dbut
Ecrire("Entrer un nombre impair :")
Lire(m)
Si m MOD 2=0 Alors
Saisie Saisie()
Sinon
Saisie
m
Fin Si
Fin

Procdure Espace(i :Entier)

Dbut
Si i>=1 Alors
Ecrire(" ")
Etoile(i*1)
!!
Fin Si
Fin
Procdure Etoile(j :Entier)
Dbut
Si j>=1 Alors
Ecrire(" ")
Etoile(j*1)
!!
Fin Si
Fin
Procdure Dessiner(k , m :Entier)
Dbut
Si k<=m Alors
Espace(m*k)
!!
Etoile(k)
!!
Etoile(k*1)
!!
Ecrire("\n")
!!
Fin Si
Fin

Dbut
n

Saisie()

Dessiner(1,n)

!!
!!

Fin

Page 19 sur 53

(
%
#
)

< ! $ %"
"!"5
< ! $ &'() %

+/,
$

,
'*6

<
<

#$
#$

;"
*

< 133=>133? @ )

<
(
(
)

G(") '8) " #'(!)

! *
+
"! *

,
,

"7"!#

#" 8+

,!

"

( #'(!)-

- Dfinir une liste simple chaine compos dune valeur entire et dun pointeur vers
llment suivant ;
1- Dclarer une variable de ce type dfini dans la question 1) ;
/- crire une procdure permettant de crer une liste chaine de n entiers.
#

, <"

<

2- crire deux procdures lune itrative et lautre rcursive permettant dafficher les
lments de la liste.
$
$

, <
! , <

0- crire une fonction rcursive qui permet de rechercher un lment x dans la liste.
! $

$ , <"

<

-<&

A- crire une procdure qui permet dajouter une tte de la liste.

6

, <"

<

4- crire une procdure qui supprimer un lment de la liste.

)

"7"!#

, <"

qui permet dinverser une liste sans utiliser un

#" 8+/

crire une procdure nomme

principe de tri bulle.
"7"!#

<

#" 8+1

crire une procdure nomme

variable temporaire.
"7"!#

&

qui permet de trier une liste chaine selon le

#" 8+2

crire une procdure qui permet de concatner deux listes chaines L1 et L2 dentiers dans
une troisime liste L3. Il faut traiter toutes les contraintes possibles.
Page 20 sur 53

"7"!#

#" 8+0

On dispose de deux listes L1 et L2 tris qui sont tris dans lordre croissant. crire une
procdure
qui permet de fusionner deux listes L1 et L2 dans la liste L1.
"7"!#

#" 8+A

crire une procdure qui permet de supprimer les doublons dans une liste chaine trie
dans lordre croissant qui contient des caractres alphabtiques. Comment peut on liminer
les doublons si la liste ntait pas trie ?
"7"!#

#" 8+4

crire une fonction qui permet de vrifier si une liste est palindrome ou non.
"

<
H

Cette liste est palindrome

'

7
Cette liste nest pas palindrome

"7"!#

#" 8+=

Une liste doublement chane est une liste qui admet, en plus de permettre l'accs au
suivant d'un lment, permet l'accs au prcdent d'un lment.
Quel est l'intrt de ce type de liste par rapport aux listes simplement chanes ?
crivez les fonctions et procdures suivantes en mettant ventuellement jour les
primitives prcdentes :
.
1.

/.
2.
0.
A.

"7"!#

, <
-<
renvoie le premier lment de L.
, <
-<
renvoie le dernier lment de L. Proposer
deux solutions lune en connaissant la queue de la liste et la deuxime en ne
connaissant pas cette dernire.
I , <
-< &
renvoie vrai si la liste est vide et faux
sinon.
,
<
- supprime le premier lment de L.
6
, ;G<
E
<
- ajoute P dans L aprs Q.
, <"
E
<
- supprime x dans L.

#" 8+?

. crire la procdure 6
circulaire L un entier e.
1. crire la procdure 6
Lun entier e.
/. crire une procdure
argument.

qui permet dajouter au dbut dune liste

qui permet dajouter la fin dune liste circulaire
$ qui affiche la liste circulaire qui lui est passe en

Page 21 sur 53

#
G(") '8) " #'(!)
! *
+
$-.

+/

,
/

"! *
,
$- 0
(

"7"!#

#" 8+

,!

"

( #'(!)-

Type
Liste : ^cellule
Cellule : Enregistrement
val

: Entier

suiv : Liste
Fin Cellule

1-

Var
L : Liste

/-

Procdure CrerListe(n : Entier ; var L : Liste)

Var
Tete, p : Liste
i : Entier
Dbut
Allouer(Tete)
Ecrire("Entrer lment Tte :")
Lire(Tete^.val)
Tete^.suiv
nil
L
Tete
Pour i de 2 n faire
Allouer(p)
Ecrire("Entrer lment n :",i)
Lire(p^.val)
p^.suiv
nil
L^.suiv
p
L
p
Fin Pour
L

Tete

Fin

Page 22 sur 53

2Procdure AffichageIter(L : Liste)

Var
p : Liste
Dbut
p
L
Tant que p nil Faire
Ecrire(p^.val)
p
p^.suiv
Fin Tant que
Fin
Procdure AffichageRecu(L : Liste)
Dbut
Si L nil Alors
Ecrire(p^.val)
AffichageRecu(p^.suiv)
Fin Si
Fin

0-

Fonction Recherche(x : Entier ; L : Liste) : Boolen

Var
p : Liste
Dbut
p
L
Tant que ((p nil) ET (p^.val x)) Faire
p
p^.suiv
Fin Tant que
Si p = nil Alors
Recherche
Faux
Sinon
Recherche
Vrai
Fin Si
Fin
%

Fonction Recherche(x : Entier ; L : Liste) : Boolen

Dbut
Si L = nil Alors
Recherche
Faux
Sinon
Si L^.val = x Alors
Recherche
Vrai
Sinon
Recherche
Recherche(x, L^.suiv)
Fin Si
Fin Si
Fin

Page 23 sur 53

AProcdure AjouterTete(x : Entier ; var L : Liste)

Var
Tete : Liste
Dbut
Allouer(Tete)
Tete^.val
x
Tete^.suiv
L
L Tete
Fin

4-

Procdure Supprimer(x : Entier ; var L : Liste)

Var
P,Q : Liste
Dbut
Si L = nil Alors
Ecrire("Liste vide, impossible de supprimer ",x)

Sinon
SiL^.val = x Alors
P
L
&
L
L^.suiv
Sinon
P
L^.suiv
Tant que ((P nil) ET (P^.val x)) Faire
Q
P
P
P^.suiv
Fin Tant que
Si P nil Alors
Q^.suiv
P^.suiv
Librer(P)
Fin Si
Fin Si
Fin Si
Fin
%

Procdure Supprimer(x : Entier ; var L : Liste)

Var
P : Liste
Dbut
Si L nilAlors
Si L^.val = x Alors
P
L
L
L^.suiv
Librer(P)
Sinon
Supprimer(x, L^.Suiv)
FinSi
FinSi
Fin
Page 24 sur 53

"7"!#

#" 8+1

Procdure Inverse (var L : Liste)

Var
P,Q : Liste
Dbut
P
nil
Tant que L nil Faire
Q
L^.suiv
L^.suiv
P
P
L
L
Q
Fin Tant que
Fin
F

0
4
?

0
4
?

3
1
"7"!#

0
3

4
?

0
15

#" 8+/

Procdure TriBulle(var L : Liste)

Var
P, Q : Liste
Temp : Entier
Dbut
P
L
Q
L^.suiv
Rpter
rep
faux
P
L
Q
L^.suiv
Tant que Q nil Faire
Si P^.val>Q^.val Alors
Temp
P^.val
P^.val
Q^.val
Q^.val
Temp
rep
vrai
Fin Si
Fin tant que
Jusqu rep = faux
Fin

Page 25 sur 53

'

"7"!#

#" 8+2

Procdure Concatener(L1,L2 :
Dbut
Si L1 = nil ET L2 = nil
L3
nil
Sinon Si L1 nil ET L2
L3
L1
Sinon Si L1 = nil ET L2
L3
L2
Sinon
'
L3
L1
Tant que
L3
Fin Tant
L3^.suiv
L3
Fin Si

Liste ; var L3 : Liste)

Alors
= nil Alors
nil Alors

()
L3^.suiv nil Faire
L3^.suiv
que
(" &
()
L2
#

L1

Fin

"7"!#

#" 8+0

Procdure Fusion(var L1 :Liste ; L2 : Liste)

Var
Tete, P, Q : Liste
Dbut
Si L1 = nil Alors
* (
L1
L2
Sinon
Si L2 nilAlors
+

Si L1^.val L2^.val Alors

Tete
L1
Sinon
Tete
L2
Fin Si
Q
Tete
Tant que L1 nil ET L2 nil Faire
Si L1^.val > L2^.val Alors
P
L2
L2
L2^.suiv
Q^.suiv
P
P^.suiv
L1
Q
P

Page 26 sur 53

Sinon Si L1^.val > L2^.val Alors

P
L2
L2 L2^.suiv
Q
L1
L1 L1^.suiv
Q^.suiv
P
P^.suiv
L1
Sinon
Q
L1
L1
L1^.suiv
Fin Si
Fin Tant que
L1
Tete
( &
#
Fin Si
Fin Si
Fin

"7"!#

Liste
trie

Liste
non
trie

#" 8+A

Procdure SupprimeDoublons(var L :Liste)

Var
Q , P : Liste
Dbut
Q
L
Si L nilAlors
Tant que Q^.suiv nilFaire
P
Q
Q
Q^.suiv
Si Q^.val = P^.valAlors
( ,
Q^.suiv
P^.suiv
Librer(P)
Fin Si
Fin Tant que
Fin Si
Fin
Procdure SupprimeDoublons(var L :Liste)
Var
Q : Liste
Vpred : caractre
Dbut
Q
L
Si L nilAlors
Tant que Q^.suiv nilFaire
Vpred Q^.val
Q
Q^.suiv
Si Q^.val = Vpred Alors
Supprimer(Vpred,Q)
Fin Si
Fin Tant que
Fin Si
Fin

Page 27 sur 53

-.

Cette procdure
se charge de
parcourir la liste
G en supprimant
toutes les valeurs
de I

"7"!#

#" 8+4

Fonction Palindrome(L : Liste) :Boolen

Var
Stop : Boolen
Deb, Fin, Q : Liste
Dbut
Deb
L
Fin nil
Stop
faux
*
Tant que Deb^.suiv FinETNON(Stop) Faire
$

Q P
Tant que Q^.suiv FinFaire
Q
Q^.suiv
Fin Tant que
Si P^.val = Q^.val Alors
Fin
Q
Sinon
Stop
vrai
#
Fin Si
Si Deb Fin Alors
Deb
Deb ^.suiv
Fin Si
Fin Tant que
Palindrome
NON(Stop)

Fin

"7"!#

#" 8+=

Lintrt dune liste doublement chaine par rapport une liste chaine simple
cest pour acclrer la recherche dun lment.
E1

E2

Queue

Tte
E3
Type
Liste : ^cellule
Cellule : Enregistrement
pred : Liste
val : Entier
suiv
: Liste
Fin Cellule
Var
L : Liste

Page 28 sur 53

Fonction Premier(L : Liste) : Liste

Dbut
Si L nullAlors
Premier
L
Sinon
Premier nil
Fin Si
Fin

1-

Fonction Dernier(Queue : Liste) : Liste

Dbut
Dernier
Queue
Fin

/"

Fonction Dernier(L : Liste) : Liste

Var
P : Liste
Dbut
P
L
Tant que P^.suiv nullFaire
P
P^.suiv
Fin Tant que
Dernier P
Fin

/Fonction estVide(L : Liste) : Boolen

Dbut
Si L = nilAlors
estVide
vrai
Sinon
estVide
faux
Fin Si
Fin

2-

Procdure supprimerPremier(var L : Liste)

Var
P : Liste
Dbut
Si L nilAlors
P
L
L
L^.suiv
L^.pred nil
Librer(P)
Fin Si
Fin

Page 29 sur 53

0-

Procdure ajouterAprs(P,Q : Liste ; var L : Liste)

Var
D :Liste
Dbut
D
L
Tant queD Q ETD nilFaire
D
D^.suiv
Fin Tant que
Si D = Q Alors
D
D^.suiv
D^.pred
p
P^.suiv
D
Q^.suiv
P
P^.pred
Q
Sinon
Ecrire("Ajout impossible, lment non existant")
Fin Si
Fin

AProcdure Supprimer(x : Entier ; var L : Liste)

Var
P,Q,D : Liste
Dbut
Si L = nil Alors
Ecrire("Liste vide, impossible de supprimer ",x)

Sinon
Si L^.val
P
L
Sinon
P
Tant

= x Alors
L
L^.suiv

L^.suiv
que ((P nil) ET (P^.val x)) Faire
Q
P
P
P^.suiv
Fin Tant que
Si P nil Alors
D
P^.suiv
D^.pred
Q
Q^.suiv
D
Librer(P)
Fin Si
Fin Si
Fin Si
Fin

Page 30 sur 53

"7"!#

#" 8+?

E1

E2
Tte
E3

.
"
Procdure AjouterTte(e : Entier ; var L : Liste)
Var
N,Tete,Queue: Liste
Dbut
Allouer(N)
N^.val
e
Si L = nilAlors
L
N
N^.suiv
L
L^.suiv
N
Sinon
Tete
L
Queue
L
Tant que Queue^.suiv TeteFaire
Queue
Queue^.suiv
Fin Tant que
Queue^.suiv
N
N^.suiv Tete
Tete
N
L Tete
Fin Si
Fin

0
#

&
0

2
#

Page 31 sur 53

Procdure affiche(L : Liste)

Var
P :Liste
Dbut
Si L = nil Alors
Ecrire("Liste vide")
Sinon
P
L!!1"
!! 1
*
Tant que P^.suiv P Faire
Ecrire(P^.val)
P
P^.suiv
Fin Tant que
Fin Si
Fin

Page 32 sur 53

1"

(
%
#
)

:
:

< 133=>133? @ )

<
<

#$
#$

;"
*

< ! $ %"
"!"5
< ! $ &'() %

+ 2,

'*6
)

"7"!#

#" 8+

")

")-

!
"!
)! )
3! 2
6! 2

5
%

8! 2
;

#" 8+1, ")

!
"!
)!
3!
6!
8!

*
)
2
2
2

:! 2

! 7

:! 2

"7"!#

")-

4
+

+ 5
5+ +
5

+ +
!
9

Page 33 sur 53

!
+

+ +

#
"7"!#

#" 8+

")

+2

")-

! .

4
3

"

8
9

-(

4 +

"!
Type
Pile : ^cellule
cellule : Enregistrement
val : Entier
suiv : Pile
Fin cellule

)!

Var
P : Pile

3!

6!

8!

:!

Procdure InitialiserPile(var P : Pile)

Dbut
P
nil
Fin
Fonction EstPileVide(P : Pile) : Boolen
Dbut
Si P = nil Alors
EstPileVide
vrai
Sinon
EstPileVide
faux
Fin Si
Fin
Procdure Empiler(x : Entier ; var P : Pile)
Var
Nv : Pile
Dbut
Allouer(Nv)
Nv^.val
x
Nv^.suiv
P
P
Nv
Fin
Procdure Dpiler(var x : Entier ; var P : Pile)
Var
S : Pile
Dbut
Si NON(EstPileVide(P)) Alors
S
P
x
P^.val
P
P^.suiv
Librer(S)
Fin Si
Fin

Page 34 sur 53

"7"!#

#" 8+1, ")

")-

! .

7
7

8
9

"!

-+

4 +

Type
Liste : ^cellule
cellule : Enregistrement
val : Entier
suiv : Liste
Fin cellule
File : Enregistrement
Tte : Liste
Queue : Liste
Fin File

)!

Var
F : File

3!

6!

8!

Procdure InitialiserFile(var F : File)

Dbut
F.Tte
nil
F.Queue
nil
Fin
Fonction EstFileVide(F : File) : Boolen
Dbut
Si F.Tte = nil Alors
EstPileVide
vrai
Sinon
EstPileVide
faux
Fin Si
Fin
Fonction Enfiler(x : Entier ; var F : File)
var
Nv : Liste
Dbut
Allouer(Nv)
Nv^.val
x
Nv^.suiv
nil
Si F.Queue nil Alors
F.Queue^.suiv
Nv
Sinon
F.Tte
Nv
Fin Si
F.Queue
Nv
Fin

Page 35 sur 53

:!
Procdure Dfiler(var B : Arbre ; var F : File)
var
P : Liste
Dbut
Si F.Tte nil Alors
P
F.Tte
B
P^.val
F.Tte
F.Tte^.suiv
Librer(P)
Fin Si
Si F.Tte = nil Alors
F.Queue
nil
Fin Si
Fin

Page 36 sur 53

(
%
#
)

<
<

< ! $ %"
"!"5
< ! $ &'() %

+ 0,
,

#$
#$

;"
*

< 133=>133? @ )

* *
$ $ -

$ -

'*6
)

(
,

"7"!#

#" 8+

,!

"

- )

1-

(
:

/- )

&6 :

2- 2

<

0- )

- 32 >2 32 ?2 )2 2 "@2 )@2 "62 6@

A- 2

4- 2

A +

=- 2

7 =

57 =

! 7
57 =

! 7
97 =

! 7

?- 2
3- 2

"7"!#

#" 8+1, ") %")(!")-

- 2
1- 2
/- 2

2- 2

0- 2
Page 37 sur 53

"7"!#

#" 8+/,

! "(!-

!#'(!) "8

On souhaite parcourir et calculer la largeur dun arbre. Pour cela nous allons implmenter
les sous programmes suivants :
- 2

1- 2

+ 5
%

+ + !

5+ + !

#
/- 2

57 =

2- 2

0- 2

"7"!#

9
=

#" 8+2

K8 % G(" I"!) " )

+ + !

57

+
=

+ !
9

G("-

B=

crire une procdure qui construit un vecteur contenant les lments dun arbre binaire.
Pour indiquer un arbre vide, il suffit de la reprsenter par le symbole .
Par exemple, ci dessous la reprsentation de larbre de la figure 1 :
11
"7"!#

1
=

/
/0

#" 8+0 ,!'

2
2

0
2

A
1/

=
1

?
0

'8)-

Figure 2 : Rotations gauche et droite

La figure ci dessus montre un exemple de rotation de droite et une rotation gauche. On

souhaite dans ce cas crer les deux procdures qui suivent :
Page 38 sur 53

"7"!#

- /

1- /

7 =
5

7 =

#" 8+A ,#' "-

crire une procdure qui permet de copier un arbre binaire A dans un deuxime arbre B.
"7"!#

#" 8+4 , () '8-

crire une procdure qui permet de fusionner deux arbres binaires A et B, et de renvoyer
un arbre C qui contient les deux arbres. Discuter les diffrents cas possibles.
"7"!#

#" 8+= , " "8"!";

'( #'%

"

On dispose des deux fonctions hauteur et taille. On souhaite crire des fonctions qui
permettent de vrifier si un arbre :
. est
:
Un arbre
est un arbre dont tous les nuds internes sont des points
simples.
Larbre < est dgnr si
57! D
57! E .
- crire la premire solution en utilisant les deux fonctions taille et hauteur.
*- crire nouveau sans utiliser les deux fonctions taille et hauteur.
1. est
:
Un arbre dont tous les niveaux sont remplis est
.
57! E
Larbre B est complet si
57! D "
B .
- crire la premire solution en utilisant la fonction hauteur.
*- crire la deuxime solution sans utiliser la fonction hauteur.
/. est
:
Un arbre est
si tous ses niveaux sont remplis, sauf le dernier dans lequel
les feuilles sont ranges le plus gauche possible.
crire une fonction permettant de vrifier si un arbre est parfait.

Page 39 sur 53

#
"7"!#

#" 8+

- *

,!

"

+0

( #'(!)-

! : Un * *
B est un ensemble de nuds qui est soit vide, soitcompos
dune racine et de deux arbres binaires disjoints
J *
et
J
*
$ .
!

F *

F *

F *

Hauteur de larbre

8L

Largeur de larbre
Un L
est un sommet qui a au moins un fils (gauche ou droit ou les deux).
Une
est un sommet qui n'a pas de fils.
La $
M
x est la longueur (en nombre d'arcs) du plus long chemin de
x une feuille.
La $
M
* est gale la hauteur de la racine.

1Type
Arbre : ^Nud
Nud : Enregistrement
Val : Entier
FilsG : Arbre
FilsD : Arbre
Fin Nud

/-

Var
A : Arbre

2-

Procdure CrerElement(x : Entier ; var B : Arbre)

Dbut
Si B = nilAlors
Allouer(B)
B^.val
x
B^.FilsG nil
B^.FilsD nil
Sinon
Si B^.val> x Alors
CrerElement(x, B^.FilsG)
Fin Si
Si B^.val< x Alors
CrerElement(x, B^.FilsD)
Fin Si
Fin Si
Fin

Page 40 sur 53

0-

- Fonction EstVide(B :Arbre) : Boolen

Dbut
Si B = nilAlors
EstVide
faux
Sinon
EstVide
vrai
Fin Si
Fin

1-

/-

Fonction EstUnFeuille(B :Arbre) : Boolen

Dbut
Si B^.FilsG = nil ET B^.FilsD = nil Alors
EstUnFeuille
vrai
Sinon
EstUnFeuille
faux
Fin Si
Fin
Fonction Recherche(x : Entier ; B : Arbre) : Boolen
Dbut
Si B=nil Alors
Recherche
faux
Sinon
Si B^.val = x Alors
Recherche
vrai
Sinon Si B^.val> x Alors
Recherche
Recherche(x, B^.FilsG)
Sinon
Recherche
Recherche(x, B^.FilsD)
Fin Si
Fin Si
Fin

2. La premire stratgie de parcours dun arbre binaire de recherche est dite en

profondeur dabord ou dans lordre prfix.

Page 41 sur 53

/
- 15 10 5 12 30 20 37
Procdure ParcoursPrfixe(B : Arbre)
Dbut
Si B nilAlors
Ecrire(B^.val)
ParcoursPrfixe(B^.FilsG)
ParcoursPrfixe(B^.FilsD)
Fin Si
Fin

1. La deuxime stratgie de parcours dun arbre binaire de recherche est dite :

parcours de larbre dans lordre
ou symtrique . Le parcours donne des
valeurs tries dans lordre croissant.

6
4

-5 10 12 15 20 30 37
Procdure ParcoursInfix(B : Arbre)
Dbut
Si B nilAlors
ParcoursInfix(B^.FilsG)
Ecrire(B^.val)
ParcoursInfix(B^.FilsD)
Fin Si
Fin

/. La troisime stratgie de parcours dun arbre binaire de recherche est dite :

parcours de larbre dans lordre
.

Page 42 sur 53

- 5 10 12 20 37 30 15
Procdure ParcoursPostfix(B : Arbre)
Dbut
Si B nilAlors
ParcoursPostfix(B^.FilsG)
ParcoursPostfix(B^.FilsD)
Ecrire(B^.val)
Fin Si
Fin
0- Le principe de suppression doit obir aux constations suivantes :
La suppression commence par la recherche de l'lment. Une fois trouv ce dernier :
si c'est une feuille, on la vire sans problmes
si c'est un sommet qui n'a qu'un fils, on le remplace par ce fils
si c'est un sommet qui a deux fils, on a deux solutions :
. le remplacer par le sommet de plus grande valeur dans le sous arbre gauche.
1. le remplacer par le sommet de plus petite valeur dans le sous arbre droit.
Pour simplifier le travail nous allons commencer par crire deux fonctions : la premire
renvoie llment qui a la plus grande valeur dans le sous arbre gauche ; la deuxime
renvoie llment qui a la plus petite valeur dans le sous arbre droit.
Fonction PlusPetitSousArbreDroit(B : Arbre)
Dbut
Si B^.FilsG nil Alors
PlusPetitSousArbreDroit

PlusPetitSousArbreDroit(B^.FilsG)

Sinon
PlusPetitSousArbreDroit

Fin Si
Fin

Fonction PlusGrandSousArbreGauche(B : Arbre)

Dbut
Si B^.FilsD nil Alors
PlusGrandSousArbreGauche

PlusGrandSousArbreGauche(B^.FilsD)

Sinon
PlusGrandSousArbreGauche

Fin Si
Fin

Page 43 sur 53

Procdure Supprimer(x : Entier ; var B : Arbre)

Var
P, Q : Arbre
Dbut
Si B = nil Alors
Ecrire ("Arbre vide ", x, " est introuvable")
Sinon
Si B^.val = x Alors
Si B^.FilsG = nil ET B^.FilsD = nil Alors
// Si cest une feuille
Librer(B)
Sinon Si B^.FilsG nil ET B^.FilsD = nil Alors
// Si le sommet admet un sous arbre gauche
B B^.FilsG
Sinon Si B^.FilsG = nil ET B^.FilsD nil Alors
// Si le sommet admet un sous arbre gauche
B B^.FilsD
Sinon Si B^.FilsG nil ET B^.FilsD nil Alors
// Si le sommet admet deux fils
// On cherche le plus petit ou le plus grand
P PlusPetitSousArbreDroit(B^.FilsD)
// ou aussi on peut chercher le plus grand
>> P PlusGrandSousArbreGauche(B^.FilsG)
Q
P
Q^.FilsG
B^.FilsG
Q^.FilsD
B^.FilsD
Librer(P)
B
Q
Fin Si
Sinon Si B^.val > x Alors
Supprimer(x, B^.FilsG)
Sinon
Supprimer(x, B^.FilsD)
Fin Si
Fin Si
Fin

"7"!#
-

#" 8+1, ") %")(!")-

Fonction Taille (B : Arbre) : Entier

Dbut
Si B = nil Alors
Taille
0
Sinon
Taille
1 + Taille(B^.FilsG) + Taille(B^.FilsD)
Fin Si
Fin

Page 44 sur 53

1Fonction Max(x,y :Entier) : Entier

Dbut
Si x>y Alors
Max
x
Sinon
Max
y
Fin Si
Fin
Fonction Hauteur(B : Arbre) : Entier
Dbut
Si B = nil Alors
Hauteur
0
Sinon
Hauteur
1 + Max(Hauteur(B^.FilsG),Hauteur(B^.FilsD))
Fin Si
Fin

/Fonction NombreDeNoeudsExternes(B : Arbre) : Entier

Dbut
Si B = nil Alors
NombreDeNoeudsExternes
0
Sinon
Si EstUneFeuille(B) Alors
NombreDeNoeudsExternes
1
Sinon
NombreDeNoeudsExternes
NombreDeNoeudsExternes(B^.FilsG) +
NombreDeNoeudsExternes(B^.FilsD)
Fin Si
Fin Si
Fin

2-

Fonction NombreDeNoeudsInternes(B : Arbre) : Entier

Dbut
Si B = nil Alors
NombreDeNoeudsInternes
0
Sinon
Si EstUneFeuille(B) Alors
NombreDeNoeudsInternes
0
Sinon
NombreDeNoeudsInternes
1 +
NombreDeNoeudsInternes(B^.FilsG) +
NombreDeNoeudsInternes(B^.FilsD)
Fin Si
Fin Si
Fin

Page 45 sur 53

0Spcification : on additionne les profondeurs des feuilles de < (non vide),

profondeur de la racine de <.

tant la

Fonction LongueurCheminArbre(B : Arbre ; prof : Entier)

Dbut
Si B = nil Alors
LongueurCheminArbre
0
Sinon
Si B^.FilsG = B^.FilsD Alors
LongueurCheminArbre
prof
Sinon
LongueurCheminArbre
LongueurCheminArbre(B^.FilsG,prof+1) +
LongueurCheminArbre(B^.FilsD,prof+1)
Fin Si
Fin Si
Fin

"7"!#

#" 8+/,

!#'(!) "8

! "(!-

=
Type
Arbre : ^nud
noued : Enregistrement
FilsG : Arbre
val : Entier
FilsD : Arbre
Fin noued
Liste : ^cellule
cellule : Enregistrement
val : Arbre
suiv : Liste
Fin cellule
File : Enregistrement
Tte : Liste
Queue : Liste
Fin File

Procdure InitialiserFile(var F : File)

Dbut
F.Tte
nil
F.Queue
nil
Fin

Page 46 sur 53

1-

/-

2-

Fonction FileEstVide(F : File) : Boolen

Dbut
Si F.Tte = nil Alors
FileEstVide
vrai
Sinon
FileEstVide
faux
Fin Si
Fin
Procdure Enfiler(B : Arbre ; var F : File)
Var
P :Liste
Dbut
Allouer(P)
P^.val
B
P^.suiv
nil
Si F.Queue nil Alors
F.Queue^.suiv
P
Sinon
F.Tte
P
Fin Si
F.Queue
P
Fin

Procdure Dfiler(var B : Arbre ; var F : File)

Var
P : Liste
Dbut
Si F.Tte nil Alors
P
F.Tte
B
P^.val
F.Tte
F.Tte^.suiv
Librer(P)
Fin Si
Si F.Tte = nil Alors
F.Queue
nil
Fin Si
Fin

Page 47 sur 53

0-

Procdure ParcoursEnLargeur(B : Arbre ; var larg :Entier)

Var
F : File
Larg_max : Entier
Dbut
Si B = nil Alors

Larg

Ecrire("Arbre vide")
Sinon
InitialiserFile(F)
Enfiler(B, F)
larg_max
0
Tant que NON(FileEstVide(F)) Faire
Dfiler(B, F)
Si B = nil Alors
Si larg > larg_max Alors
larg_max
larg
Fin Si
Si NON(FileEstVide(F)) Alors
larg
0
Enfiler(x,F)
Fin Si
Sinon
larg
larg + 1
Ecrire(B^.val)
Si B^.FilsG nil Alors
Enfiler(B^.FilsG, F)
Fin Si
Si B^.FilsD nil Alors
Enfiler(B^.FilsD, F)
Fin Si
Fin si
Fin Tant que

larg

larg_max

Fin Si
Fin

"7"!#

#" 8+2

K8 % G(" I"!) " )

G("-

Procdure ConstruireVecteur(B :Arbre ; var n :Entier ; var T :TAB)

Dbut
Si B = nil Alors
T[i]

Sinon
T[i]
B .val
ConstruireVecteur(B^.FilsG, 2*n, T)
ConstruireVecteur(B^.FilsD, 2*n+1, T)
Fin Si
Fin

Page 48 sur 53

"7"!#

#" 8+0 ,!'

'8)-

Procdure rotation_droite(var B : Arbre)

Var
Temp : Arbre
Dbut
Temp
B^.FilsG
B^.FilsG
B^.FilsD
B^.FilsD
Temp
B
Temp
Fin
Procdure rotation_gauche(var B : Arbre)
Var
Temp : Arbre
Dbut
Temp
B^.FilsD
B^.FilsD
B^.FilsG
B^.FilsG
Temp
B
Temp
Fin

"7"!#

#" 8+A ,#' "-

Procdure Copier(A : Arbre ; var B : Arbre)

Dbut
Si A nil Alors
CrerElement(A^.val, B)
Copier(A^.FilsG,B)
Copier(A^.FilsD,B)
Fin Si
Fin

"7"!#

#" 8+4 , () '8-

Procdure Fusion(A,B: Arbre ; var C : Arbre)

Dbut
Si A nil ET B = nil Alors
Copier(A,C)
Sinon Si A = nil ET B nil Alors
Copier(A,C)
Sinon
Si A nil ET B nil Alors
Si A^.val > b^.val Alors
CrerElement(A^.val,C)
Fusion(A^.FilsG,B,C)
Fusion(A^.FilsD,B,C)
Sinon
CrerElement(A^.val,C)
Fusion(A,B^.FilsG,C)
Fusion(A,B^.FilsD,C)
Fin Si
Fin Si
Fin Si
Fin

Page 49 sur 53

"7"!#

#" 8+= , " "8"!";

'( #'%

"

. Un arbre
est un arbre dont tous les nuds internes sont des points simples.
Larbre < est dgnr si
57! D
57! E .

<"

F *

La figure 1 montre quun arbre dgnr admet pour chaque sommet un seul fils.
<
<
$
Fonction EstDegenere(B : Arbre) : Boolen
Dbut
Si B = nil Alors
EstDegenere
vrai
Sinon
Si (B^.FilsG nil) ET (B^.FilsD nil) Alors
EstDegenere
faux
Sinon
Si B^.FilsG = nil Alors
EstDegenere
EstDegenere(B^.FilsD)
Sinon
EstDegenere
EstDegenere(B^.FilsG)
Fin Si
Fin Si
Fin Si
Fin
1
<
<
$
Fonction EstDegenere(B : Arbre) : Boolen
Dbut
Si (Taille(B) = Hauteur(B)+1) Alors
EstDegenere
vrai
Sinon
EstDegenere
faux
Fin Si
Fin

Page 50 sur 53

1. On appelle arbre binaire

2 fils. Larbre B est complet si

1<"

un arbre binaire tel que chaque sommet possde 0 ou

57! E

57! D "

B .

F *

La figure 2 montre quun arbre complet admet pour chaque sommet zro fils ou deux fils.
<
$
Fonction EstComplet(B : Arbre, h :Entier) : Boolen
Dbut
Si B = nil Alors
EstComplet
(h=*1)
Sinon
EstComplet
EstComplet(B^.FilsG, h*1)
ET
EstComplet(B^.FilsG, h*1))
Fin Si
Fin
Complet : Boolen
Complet
EstComplet(B,Hauteur(B))
1

<

F$

Fonction EstComplet(B : Arbre) : Boolen

Var
F : File
Larg, larg_prochain : Entier
Dbut
Si B = nil Alors
EstComplet
vrai
Sinon
Initialiser(F)
Enfiler(B, F)
Larg
0
larg_prochain
1
Tant que NON(EstVide(F)) Faire
Dfiler(B,F)
Si B = nil Alors
Si larg larg_prochain Alors
ViderFile(F)
EstComplet
faux
Fin Si
Si NON(EstVide(F) Alors
larg_prochain
2 * larg
larg 0
Enfiler(nil, F)
Fin si

Page 51 sur 53

Sinon
Larg
Larg + 1
Si B .FilsG nil Alors
Enfiler(B FilsG, F)
Fin Si
Si B .FilsD nil Alors
Enfiler(B FilsD, F)
Fin Si
Fin si
Fin Tant que
EstComplet
vrai
Fin si
Fin

/. On appelle arbre binaire

un arbre binaire (complet) tel que chaque sommet est
le pre de
sous arbres de N
$
,
/-.
+1
Un arbre binaire parfait possde 2 1 sommets, o est la hauteur de l'arbre.
Fonction EstParfait(B : Arbre) : Boolen
Var
F : File
fils_vide, parfait : Boolen
Dbut
Si B = nil Alors
EstParfait
vrai
Sinon
Initialiser(F)
Enfiler (B, F)
fils_vide
faux
parfait
faux
Tant que NON(EstVide(F) ET NON(fils_vide) Faire
Dfiler(B,F)
Si B^.FilsG = nil Alors
fils_vide
vrai
parfait
(B^.FilsG = nil)
Sinon
Enfiler (B^.FilsG, F)
Si B^.FilsD nil Alors
Enfiler (B^.FilsD, F)
Sinon
fils_vide
vrai
Fin Si
Fin Si
Fin Tant que
Tant que NON(EstVide(F)) ET parfait Faire
Dfiler(B,F)
parfait
(B^.FilsG = B^.FilsD)
Fin tant que
Initialiser(F)
EstParfait
parfait
Fin si
Fin

Page 52 sur 53

&

&

' !

5"

S. ROHAUT : Algorithmique et Techniques fondamentale de programmation, Edition Eni

2007.
LIGNELET P., Algorithmique. Mthodes et modles, Paris : Masson, 1985.
www.intelligentedu.com/blogs/post/free_computer_books/3760/the algorithm design
manual/fr/

Page 53 sur 53