TD.

Enonc :
Raliser les exercices suivants en faisant ventuellement les hypothses
supplmentaires qui vous paratrons pertinentes en les justifiant.
- Concevoir un algo qui permet d'liminer toutes les rptitions dans une
liste
- Concevoir un algo qui permet de fusionner deux listes tries dans l'ordre
croissant
- Concevoir un algo pour dplacer des entiers contenus dans une pile p
vers une pile p! de fa"on # avoir tous les nom$res pairs au dessus des
nom$res impairs
- Concevoir un algo pour trier une file f dans une file f!. Crer les
oprations intermdiaires qui vous paratrons ncessaires pour une $onne
lisi$ilit
Conseils
%ente& de mettre votre dmarche de conception algorithmique en vidence
hypothse' un nonc (doit( )tre interprt pour )tre traduit en
algorithme.
Correction :
Fonction liste rptition (L)
E/S
L : Liste
Dclaration
i,j : entier
Dbut
Si longueur (L) = ou longueur (L) = ! alors
"etourner (L)
Sinon
i!
Tant #ue i $ longueur (L) %aire
ji&!
Tant #ue j$= longueur (L)
Si '()e (L,j) = '()e (L,i) alors
L"etire*el)t (L,j)
Sinon
jj&!
FinSi
FinT#
ii&!
FinT#
"etourner (L)
FinSi
Fin
Co)ple+it ,e l-algo = .&!&n/(!&0&n/(!&0)&0) = 1&n/(2&.n) = 1&2n&.n3
4erso :
4roce,ure Fusion (L!,L0,L.)
E
L!,L0 : liste
S
L. : liste
Declaration
i,j,5 : entire
Dbut
i!
j!
5!
Tant #ue i$=longueur(L!) et j$=Longueur(L0) %aire
Si '()e (L!,i) = '()e (L0,j) alors
L.657L!6i7
L.65&!7L06j7
jj&!
ii&!
55&0
Sinon
Si '()e(L!,i) $ '()e(L0,j) alors
L.657L!6i7
ii&!
Sinon
L.657L06j7
jj&!
Finsi
55&!
Finsi
Fint#
8rer cas ou il reste ,es ele)ents ,ans L! ou L0.
Correction ,u TD :
Raliser les exercices suivants en faisant ventuellement les hypothses
supplmentaires qui vous paratrons pertinentes en les justifiant.
- Concevoir un algo qui permet d'liminer toutes les rptitions dans une
liste
- Concevoir un algo qui permet de fusionner deux listes tries dans l'ordre
croissant
- Concevoir un algo pour dplacer des entiers contenus dans une pile p
vers une pile p! de fa"on # avoir tous les nom$res pairs au dessus des
nom$res impairs
- Concevoir un algo pour trier une file f dans une file f!. Crer les
oprations intermdiaires qui vous paratrons ncessaires pour une $onne
lisi$ilit.
Conseils
%ente& de mettre votre dmarche de conception algorithmique en vidence
hypothse' un nonc (doit( )tre interprt pour )tre traduit en
algorithme.
**************************************************************************
+uggestion de correction
,our l'ensem$le des pro$lmes poss- l'exercice algorithmique consiste .
savoir ou dcider des (outils( qui seront utiliss pour rsoudre le
pro$lme en fonction des contraintes que l'on voudra s'imposer pour celle
qui ne sont pas explicitement poses dans l'nonc /choix ou non d'une
implmentation particulire- rsolution . partir d'un jeu de primitives
(fourni( pour le modle de donnes- etc.0. Ce sont- en gnral des critres
de lisi$ilit et1ou de calcul de complexit qui permettent de prendre les
dcisions avant de raliser l'criture de l'algorithme proprement dit.
2es exemples varis de (solutions( ci-dessous
***************************************************************************
- Concevoir un algo qui permet d'liminer toutes les rptitions dans une
liste
3uestion ' 4st-il ncessaire de se proccuper de l'implmentation 5
6es considrations d'implmentation ne sont ici importantes que si l'on
considre que l'on peut mieux faire qu'une rsolution quadratique. Ceci
sem$le possi$le si l'on peut raliser un tri entre les lments de la
liste. 7r rien- dans l'nonc ne prcise que les lments contenus dans la
liste sont tria$les. 8ous considrerons donc de nous contenter d'une
rsolution algorithmique utilisant les primitives classiques vues en cours'
ime- longueur- insrer- supprimer-
Remarque' on supposera galement que l'on dispose d'une primitive qui
permet de comparer deux lments
compare/type9element e- type9element e!0
:oici une suggestion en fran"ais d'un algorithme rcursif pour rsoudre le
pro$lme
Conception rcursive'
4liminer tous les dou$lons dans une liste c'est'
si la liste est vide ou compose d'un seul lment
renvoyer la liste
sinon
renvoyer une liste dans laquelle on insrera en t)te
l'lment plac! en t)te dans la liste en argument dans une liste rsultat
de l'appel rcursif sur une liste dans laquelle on aura enlev tous les
!lments identiques . l'lment plac en t)te
Ce qui ncessite de pouvoir enlever un lment dans une liste
4nlever un lment e dans une liste c'est'
si la liste est vide
renvoyer la liste
sinon
+i l'lment plac en t)te est identique # l'lment e
renvoyer la liste rsultat de l'appel rcursif sur
la liste prive de son premier lment
+inon
renvoyer une liste dans laquelle on insrera en t)te
l'lment plac en t)te dans la liste en argument dans la liste rsultat de
l'appel rcursif sur la liste prive de son premier lment
4n conclusion- pour faciliter la lisi$ilit- il est judicieux de crer les
outils suivants . partir des primitives
inserer9en9tete/l-e0 quivalent # insrer/l-e-0
supprimer9en9tete/l0 equivalent 0 supprimer/l-0 /attention- une
prcondition pour utiliser cette opration est que la liste doit )tre non
vide0
supprimer9element /description ci-dessus0
6es solutions qui utilisent une implmentation particulire conduisent .
l'criture d'une nouvelle primitive pour ce type d'implmentation. 2ans ces
cas l#- on conclura en donnant la complexit de l'algorithme fourni.
**************************************************************************
- Concevoir un algo qui permet de fusionner deux listes tries dans l'ordre
croissant
;on interprtation de l'nonc me conduit . dcider que le pro$lme
consiste . crer une liste rsultat . partir de deux listes fournies en
argument. 4n effet- prendre la dcision d'craser une des listes fournie ne
me parat pas une solution pertinente au seul regard de devoir choisir
ar$itrairement laquelle.
Conditions dans lesquelles la solution est immdiate...
+i une des deux listes est vide alors la solution consiste . renvoyer
l'autre liste /m)me si elle est vide0
2ans le cas gnral /aucune des deux listes n'est vide0' renvoyer une liste
dans laquelle on insre en t)te le plus petit des deux lments figurant en
t)te dans les deux listes fournies en argument dans une liste rsultat de
l'appel rcursif sur les deux listes dont l'une aura t prive de
l'lment plac en t)te dans la liste rsultat
complexit linaire<
***************************************************************************
- Concevoir un algo pour dplacer des entiers contenus dans une pile p
vers une pile p! de fa"on # avoir tous les nom$res pairs au dessus des
nom$res impairs
8ous considrerons que nous disposons des primitives suivantes concernant
les piles' creer9pile9vide-empiler-dpiler-sommet-pile9vide
et d'une fonction de test de parit' est9pair
et d'une fonction $oolenne de ngation' non
6e plus simple sem$le ici d'utiliser une troisime pile p= pour (faire le
tri(.
7n (vide( la pile p en pla"ant l'entier au sommet dans p! s'il est impair
et dans p= s'il est pair tant que celle-ci n'est pas vide... puis on (vide
p= dans p!(.
>lgo'
p= ?- creer9pile9vide/0
%ant3ue /non/pile9vide/p00
+i est9pair/sommet/p00
empiler/p=-sommet/p00
+inon
empiler/p!-sommet/p00
depiler/p0
@in%ant3ue
%ant3ue/non/pile9vide/p=00
empiler/p!-sommet/p=00
depiler/p=0
@in%ant3ue
7n pourra utiliser une varia$le locale pour viter d'valuer deux fois le
sommet de p. 8otons toutefois que cela ne change pas la complexit de
l'algorithme... qui est linaire.
.A la fin de l'excution de cette procdure- la pile p! contient l'ensem$le
des entiers prala$lement contenus dans p avec les nom$res pairs (au
dessus(
exemple d'excution' si p contient /en partant du sommet0'
B-C-D-E-F-G-=-!- et que p! est vide au d$ut
p! contiendra . la fin de l'excution /en partant du sommet0'
C-E-G-!--=-F-D-B
***************************************************************************
*******
- Concevoir un algo pour trier une file f dans une file f!. Crer les
oprations intermdiaires qui vous paratrons ncessaires pour une $onne
lisi$ilit
8ous considrerons que nous disposons des primitives suivantes concernant
les files' creer@ile:ide-enfiler-dfiler-premier-file:ide
et
d'une fonction defiler4nfiler qui prend deux files f et f! en arguments et
qui dfile le premier lment de la premire file et l'ajoute . la
deuxime file
d'une fonction qui permet de comparer le premier de deux files f et f! et
renvoie vrai si le premier de f est plus grand /ou gal0 et faux sinon'
compare
d'une fonction qui permet de permuter le contenu d'une file f dans une
file f!' permute@ile
et d'une fonction $oolenne de ngation' non
7n s'adjoindra une file f=
>lgo'
f= ?- creer@ile:ide/0
%ant3ue non/file:ide/f00
%ant3ue non/file:ide/f!00 et que comparer/f-f!0
defiler4nfiler/f!-f=0
@in%ant3ue
defiler4nfiler/f-f=0
%ant3ue non/file:ide/f!00
defiler4nfiler/f!-f=0
@in%ant3ue
permute@ile/f=-f!0
@in%ant3ue
Cours 2 9 !: ;ars 0<.
Tri a=ec )eilleur co)ple+it : tri %usion.
;o,(le ,e ,onnes non linaires : >rbre
(;iss un bout)
E+e)ple et ter)inologie.
? C@a#ue el)t ,-un arbre est un nAu,.
? Les nAu,s sont relis les uns au+ autres par une relation ,-or,re
(@irarc@ie).
? Bn nAu, a un p(re (au plus).
? Bn nAu, #ui a au )oins un %ils est un nAu, interne.
E+e)ple ,-arbre :
"acine
CAu, interne CAu, interne Feuille
Feuille Feuille CAu, interne
Feuille
L-arit ,-un arbre est caractrise par le no)bre )a+i)u) ,e %ils pour un nAu,.
Dn parle ,-arbre n?aire.
L-arit n-i)pose pas ,e nb )ini)u) ,e %ils (un nAu, ,-un arbre ternaire aura ,!,0
ou . %ils).
Le ,egr ,-un nAu, est le nb ,e %ils #ue poss(,e ce nAu,.
()iss un bout).
Bsages :
>rbre ,e ,cision
>nalEse sEnta+i#ue
SEst()e ,e gestion ,e %ic@iers
Classi%ication
Etc F
4assage ,-un arbre n?aire G un arbre binaire. E+ = arbre gnalogi#ue.
TEper ,i%re)ent les liens entre nAu,s.
E+ = Flec@e est ouest : !
er
en%ant
Flec@e ouest est : %r(re/sAur.
Taille ,-un arbre : nb ,e nAu,s internes (ou nAu,s en gnral selon l-usage) #ui le
co)pose.
4ro%on,eur ,-un nAu, : la ,istance en ter)es ,e nAu,s par rapport G la racine.
Le nAu, racine est ,e pro%on,eur nulle par con=ention.
Hauteur ,-un arbre : pro%on,eur )a+i)u) ,e ces nAu,s.
C-est aussi le )a+i)u) ,e la @auteur ,e ses %ils.
La @auteur est un crit(re ,e I per%or)ance J pour un arbre.
>rbre locale)ent co)plet : arbre ,ont c@a#ue nAu, a ou 0 %ils. Les nAu,s
internes auront ,ons tous 0 %ils.
E+ : "acine DK
"acine CAu, 'nt Feuille DK
Feuille
Feuille
>rbre ,gnr : un arbre ,ont les nAu,s ne poss(,ent #u-un seul %ils.
E+ : >LCD
Dn appellera un arbre binaire co)plet un arbre #ui est locale)ent co)plet et ,ont
toutes les %euilles on la )M)e pro%on,eur.
Dn peut calculer la taille e+acte ,-un tel arbre en %onction ,e sa @auteur.
E+ = "acine CAu, int %euille
%euille
CAu, int %euille
%euille
H = @auteur ,e l-arbre. 6'ci 07.
Taille = N (i= @) 0Oi = 0O(@&!) ? !.
La @auteur ,-un arbre co)plet Pest en P lg n.
Bn arbre est ,it par%ait si tous les ni=eau+ sont re)plis sau% =entuelle)ent le
,ernier. Dans ce cas les %euilles ,oi=ent Mtre groupes G I gauc@e J.
Si on appelle le %ils gauc@e ,-un arbre binaire le sous arbre gauc@e et
rcipro#ue)ent le %ils ,roit ,-un arbre binaire le sous?arbre ,roit, alors on pourra
noter un arbre sous la %or)e sui=ante :
>rbre*=i,e
Du
$CAu,, sous?arbre gauc@e, sous?arbre ,roitQ
Sorte : >rbre
Btilise : Raleur CAu,
Dprations :
>rbre*=i,e :
>rbre
$?,?,?Q : CAu, + >rbre + >rbre
>rbre
"acine : >rbre
CAu,
8auc@e : >rbre
>rbre
Droit : >rbre
>rbre
Contenu : CAu,
Raleur
>=ec > et L ,e sorte arbre et n ,e sorte nAu,.
4r con,itions :
"acine(>) est ,%inie ssi > n-est pas =i,e
8auc@e (>) est ,%ini ssi ! n-est pas =i,e
Droit (>) est ,%ini ssi > n-est pas =i,e
>+io)es :
"acine ($n,>,LQ) = n
8auc@e ($n,>,LQ) = >
Droit ($n,>,LQ) = L
')pl)entation : ,ans un tableau ou a=ec une structure nAu,.
Le c@oi+ se %era s=t en %onction ,e proprits suppl)entaires associes G ,es
arbres.
TD (structure ,e ,onnes et pri)iti=es associs) : e+e)ple ,u tas (ou %ile ,e priorit
ou @eap).
Bn tas est un )o,(le ,e ,onnes #ui per)et ,e grer une %ile ,-attente F
a=ec ,es priorits. Le )o,(le ,e ,onnes utilis n-est pas linaire et correspon, G
un arbre binaire aEant les proprits sui=antes :
Bn tas ncessite #u-il e+iste un or,re sur les =aleurs contenues ,ans la
@irarc@ie.
La =aleur ,e c@a#ue nAu, est suprieure ou gale G celle ,e ses %ils.
C-est un arbre par%ait.
Dprations suppl)entaire pour tas :
'nsertion : Tas + Raleur Tas
Suppression : Tas Tas
C% %euille pour e+e)ples ,-insertion et ,e supression.
Soit i la position ,-un nAu,. i rapport au ni=eau (racine ni=eau , ses %ils ni=eau !,
petits %ils ni=eau 0 rapport au 0O el)ts au ni=eau , 0O! au ni=eau !, 03 au ni=eau
0, F)
Fils gauc@e : 0/i
Fils ,roit : (0/i)&!
4(re : i/0.
Structure pour un tas
TEpe*el)t tableau 6;>SS'TE7
Struct tas U
'nt taille V
TEpe*el)t / tableau V
'nt taille*)a+ V // correspon, a la taille alloue au tableau.
W
TEpe,e% struct tas / tas*p V // ,e% ,-un tEpe #ui est un pointeur sur un tas.
')pl)ent algo pour entasser, pour retirer le )a+.
Rersion perso :
Roi, Entasser (tas*p t, tEpe*el)t e)
U
'nt i,j V
TEpe*el)t Te)p V
'% (ttaille $ ttaille*)a+)
U
(ttaille) && V
i = ttaille V
(ttableau6i7) = e V
j = i ,i=ision eucli,ienne par 0 V
X@ile ((ttableau6i7) Q (ttableau6j7) YY j Q )
Z U
Te)p = (ttableau6j7)V
(ttableau6j7) = eV
(ttableau6i7) = Te)p V
i = j V
j = i ,i=ision eucli,ienne par 0 V
W
W
W
Correction ;at@on :
4rcon,itions : traite)ent ,e taille*)a+.
Soit pos une =ariable pour la position ,-insertion ,e l-l)ent e.
'ncr)ente[ la taille ,u tas.
'nitialise[ pos G la taille ,u tas.
Tant #ue l-l)ent G insrer e est suprieur G la =aleur ,e son p(re 6pos / 07 (s-il en
e+iste un) : la =aleur ,u p(re est place G la position pos. La position pos ,e=ient
celle ,u p(re.
Fin Tant #ue.
L-l)ent e est plac G la position pos.
.