exercices corrigés d'algorithmique

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

Anne Universitaire : 20082009

sur 53

!"#"

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 sousprogrammes 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 sousprogrammes 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 celuil 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.

!$%"$

!$&'()%

sur 53

*

+,$-......................................................................................../

#+............................................................................................................................0

+1,!-............................................................................................................................1

#+1..........................................................................................................................2

+/,$-..............................................................................................................13

#+/..........................................................................................................................11

+2,-...............................................................................................................//

#+2........................................................................................................................../2

+0,**$$-................................................................................................./4

#+0..........................................................................................................................23

&&'! 5"....................................................................................................................................0/

sur 53

+,$-

,$-

'*6

"7"!##"8+

Crer un enregistrement nomm " qui est caractris par un , un

et 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 " afin quelle puisse tre en relation avec

lenregistrement 8 .

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 sousprogrammes.

"7"!##"8+/

On souhaite mmoriser des noms des personnes dans un fichier nomm ..

On vous demande alors de crer les sousprogrammes 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 sousprogrammes.

):;":*

(133?@)1

%

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.

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

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

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

sur 53

"7"!##"8+2

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

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

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

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

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

sur 53

+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 luimme).

"7"!##"8+2

9crire une procdure rcursive qui permet dinverser une chaine de caractres sans utiliser

une chaine temporaire.

information noitamrofni

"7"!##"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" vrai

"7"!##"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" faux

):;":*

(133?@)1

%

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&qui permet de trier un tableau

T de n entiers. Utiliser les deux procdures cidessous :

,;Dd 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

sur 53

"7"!##"8+=

"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 iT[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

Procdure PermutCirc(var ch :chaine)

Dbut

!!

Si LONG(ch)>1 Alors

!!

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

Fin Si

Fin

sur 53

F

!

"#

$"

%"

&&

'((

$

% ")*#.

# !

"#

$" "#

%"#$"

&& %"#

'(( &&

$ '((

%#")*#. $

+ ! %#")*#(,

"# +#!

$" "#

%"+$"

&&%"+

'((&&

$'((

%+")*#&$

-/%+")*#&

/,-+

0,

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

-+(%

+-+(%

(&++#11//,

-+(%

+-+(%

(&++#1120,

sur 53

"7"!##"8+3 .

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

SaisieSaisie()

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

sur 53

+/,$-,$-

'*6< (

(

)

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. #,

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 peuton 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 H A

Cette liste est palindrome

' 7 H O

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 : . ,

sur 53

Type

Liste : ^cellule

Cellule : Enregistrement

val : Entier

suiv : Liste

Fin Cellule

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

#+/

G(")'8)"#'(!) ! *+,

$-.

/

"! *

,

$- 0

(

(

"7"!##"8+,! "(#'(!)- -

1-

/-

sur 53

Procdure 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

%

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

2-

0-

sur 53

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

Var

Tete : Liste

Dbut

Allouer(Tete)

Tete^.val x

Tete^.suiv L

LTete

Fin

%

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

%


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

A-

4-

sur 53

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

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

"7"!##"8+1

FFJ

0 4 ? 3 1

"7"!##"8+/

0 4 0 ? 4 0 3 ? 4 0 1 3 ? 4 15

sur 53

Procdure Concatener(L1,L2 : Liste ; var L3 : Liste)

Dbut

Si L1 = nil ET L2 = nil Alors

L3 nil

Sinon Si L1 nil ET L2 = nil Alors

L3 L1

Sinon Si L1 = nil ET L2 nil Alors

L3 L2

Sinon

'(

L3 L1

()

Tant que L3^.suiv nil Faire

L3 L3^.suiv

Fin Tant que

("&()

L3^.suiv L2

#

L3 L1

Fin Si

Fin

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

"7"!##"8+2

"7"!##"8+0

sur 53

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

P L2

L2L2^.suiv

Q L1

L1L1^.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

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

VpredQ^.val

Q Q^.suiv

Si Q^.val = Vpred Alors

Supprimer(Vpred,Q)

Fin Si

Fin Tant que

Fin Si

Fin

"7"!##"8+A

Cette procdure se charge de

parcourir la liste G en supprimant toutes les valeurs

de I

Liste

trie

Liste

non

trie

sur 53

Type

Liste : ^cellule

Cellule : Enregistrement

pred : Liste

val : Entier

suiv : Liste

Fin Cellule

Var

L : Liste

"7"!##"8+4

"7"!##"8+= Lintrt dune liste doublement chaine par rapport une liste chaine simple

cest pour acclrer la recherche dun lment.

E1

E2 E3

Fonction Palindrome(L : Liste) :Boolen

Var

Stop : Boolen

Deb, Fin, Q : Liste

Dbut

Deb L

Finnil

Stop faux *

Tant que Deb^.suiv FinETNON(Stop) Faire

$

QP

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

Tte

Queue

sur 53

Fonction Premier(L : Liste) : Liste

Dbut

Si L nullAlors

Premier L

Sinon

Premiernil

Fin Si

Fin

*/"0

Fonction Dernier(L : Liste) : Liste

Var

P : Liste

Dbut

P L

Tant que P^.suiv nullFaire

P P^.suiv

Fin Tant que

DernierP

Fin

Fonction estVide(L : Liste) : Boolen

Dbut

Si L = nilAlors

estVide vrai

Sinon

estVide faux

Fin Si

Fin

Procdure supprimerPremier(var L : Liste)

Var

P : Liste

Dbut

Si L nilAlors

P L

L L^.suiv

L^.prednil

Librer(P)

Fin Si

Fin

-

1-

/-

2-

*/ 0

Fonction Dernier(Queue : Liste) : Liste

Dbut

Dernier Queue

Fin

sur 53

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


Var

P,Q,D : Liste

Dbut

Si L = nil Alors

Ecrire("Liste vide, impossible de supprimer ",x)

Sinon

Si L^.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

D P^.suiv

D^.pred Q

Q^.suiv D

Librer(P)

Fin Si

Fin Si

Fin Si

Fin

0-

A-

sur 53

"7"!##"8+?

.

"

$01&2

0

#01#.

E1

E2

E3

Tte

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^.suivTete

Tete N

LTete

Fin Si

Fin

sur 53

Procdure affiche(L : Liste)

Var

P :Liste

Dbut

Si L = nil Alors

Ecrire("Liste vide")

Sinon

P L!!1"

!!1*1"

Tant que P^.suiv P Faire

Ecrire(P^.val)

P P^.suiv

Fin Tant que

Fin Si

Fin

sur 53

+2,-,-

'*6

)

"7"!##"8+,") ")- !

"!

)! )

3! 245!

6! 2%5!7

8! 2 5 9 ! 3

:! 2;59!

"7"!##"8+1,")")- ! *+/

"!

)! )

3! 24+5++!

6! 2+%5++!

8! 2 5 9 + +! 3

:! 2;59++!

):;":*

(133?@)1

%

3

" 7 8(

9

-(4+

"!

)!

3!

6!

8!

:!

Type

Pile : ^cellule

cellule : Enregistrement

val : Entier

suiv : Pile

Fin cellule

Var

P : Pile

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

sur 53

"7"!##"8+1,")")- ! . 4 56

-

73

7

7 8(

9

-+4+

"!

)!

3!

6!

8!

Type

Liste : ^cellule

cellule : Enregistrement

val : Entier

suiv : Liste

Fin cellule

File : Enregistrement

Tte : Liste

Queue : Liste

Fin File

Var

F : File

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

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

sur 53

+0,**$$-,**$$-

'*6 )(

,

1

-(

"7"!##"8+,! "-

- ),

1- (

:

/- )

&6:

2- 2232?2)2 2"@2)@2"626@

A- 2 %57=!7

4- 2A+57=!7

=- 2$597=!7

?- 2

3-2 *

5 9 7 =!

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

- 2

1- 2

/- 2;46

2- 2;

0- 2

):;":*

(133?@)1

%

- *+,

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

Un Lest 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 $Mx est la longueur (en nombre d'arcs) du plus long chemin de

x une feuille. La $M*est gale la hauteur de la racine.

1-

/-

2-

Type

Arbre : ^Nud

Nud : Enregistrement

Val : Entier

FilsG : Arbre

FilsD : Arbre

Fin Nud

Var

A : Arbre

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

Dbut

Si B = nilAlors

Allouer(B)

B^.val x

B^.FilsGnil

B^.FilsDnil

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

F

N

F F F

N

!F*

F*

8LF*

Largeur de larbre

Ha

ute

ur d

e la

rbre

sur 53

0-

-

1-

/-

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

profondeur dabord ou dans lordre prfix.

Fonction EstVide(B :Arbre) : Boolen

Dbut

Si B = nilAlors

EstVide faux

Sinon

EstVide vrai

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

Fonction EstUnFeuille(B :Arbre) : Boolen

Dbut

Si B^.FilsG = nil ET B^.FilsD = nil Alors

EstUnFeuille vrai

Sinon

EstUnFeuille faux

Fin Si

Fin

sur 53

-15 10 5 12 30 20 37

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.

-5 10 12 15 20 30 37

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

Procdure ParcoursPrfixe(B : Arbre)

Dbut

Si B nilAlors

Ecrire(B^.val)

ParcoursPrfixe(B^.FilsG)

ParcoursPrfixe(B^.FilsD)

Fin Si

Fin

1

/

2

0

A

Procdure ParcoursInfix(B : Arbre)

Dbut

Si B nilAlors

ParcoursInfix(B^.FilsG)

Ecrire(B^.val)

ParcoursInfix(B^.FilsD)

Fin Si

Fin

/ 0 3

45

6

sur 53

- 5 10 12 20 37 30 15

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.

/

0

6

4

5

3

Procdure ParcoursPostfix(B : Arbre)

Dbut

Si B nilAlors

ParcoursPostfix(B^.FilsG)

ParcoursPostfix(B^.FilsD)

Ecrire(B^.val)

Fin Si

Fin

Fonction PlusPetitSousArbreDroit(B : Arbre)

Dbut

Si B^.FilsG nil Alors

PlusPetitSousArbreDroit PlusPetitSousArbreDroit(B^.FilsG)

Sinon

PlusPetitSousArbreDroit B

Fin Si

Fin

Fonction PlusGrandSousArbreGauche(B : Arbre)

Dbut

Si B^.FilsD nil Alors

PlusGrandSousArbreGauche PlusGrandSousArbreGauche(B^.FilsD)

Sinon

PlusGrandSousArbreGauche B

Fin Si

Fin

sur 53

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

-

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 BB^.FilsG Sinon Si B^.FilsG = nil ET B^.FilsD nil Alors

// Si le sommet admet un sous arbre gauche BB^.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

Fonction Taille (B : Arbre) : Entier

Dbut

Si B = nil Alors

Taille 0

Sinon

Taille 1 + Taille(B^.FilsG) + Taille(B^.FilsD)

Fin Si

Fin

sur 53

1-

/-

2-

Fonction 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

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

sur 53

0-

"7"!##"8+/, !#'(!)"8!"(!-

=

-

Spcification : on additionne les profondeurs des feuilles de

exercices corrigés d'algorithmique

Documents