Séance 1 : TD Récursivité [14:39] mohamed amine ben chiba

procedure inverse ( var T : tableau [1..Max] d’entiers ; i,n: entier)

var
x:entier

debut

si (i < n) alors
Fonction Ack(M,N : entier) : entier
x<-T[n]
Var T[n]<-T[i]
T[i]<-x
Début

Si (M=0) Alors inverse( T,i+1,n-1)

Retourner(N+1) fsi
fin.
Sinon

Si (N=0) Alors Exemple :

Retourner (Ack(M-1,1)) T:

Sinon 2 5 1 3 10

Retourner(Ack(M-1,Ack(M,N-1))) 1 2 3 4 5

Fsi x:5

Fsi Appel initial : inverse(T,1,5)

Si 1<5 ? oui

Fin Permuter les contenus de T[1] et T[5]

Inverse(T,2,4)

Si 2<4 ? oui

Permuter les contenus de T[2] et T[4]

Inverse(T,3,3)

Si 3<3 ? NON STOP

[15:12] Mazen Mdimegh Appel initial : occurrence(T,5,5)=3

Si 5>0 ? OUI
Type :
si T[5]=5 ?
Tab=tableau[1..Max] d’entiers
(1+occurrence(T,5,4)=2)=3
fonction occurence(t:tab ; x,n,i:entier): entier
Debut Si 4>0 ? oui
si (i<=n) alors
siT[4]=5 ?oui
si t[i]=x alors
retourner (1+ occurence(t,x,n,i+1)) (1+occurrence(T,5,3)=1)=2
sinon
retourner(occurence(t,x,n,i+1)) Si 3>0 ? oui

Si T[3]=5 ?
fsi
Occurrence(T,5,2)=1
sinon
Si2>0 ?oui
retourner(0) Si T[2]=5 ? oui

fsi (1+occurrence(T,5,1)=0)=1
Fin Si 1 >0 ? oui

version 2 Si T[1]=5 ? NON

Occurrence(T,5,0)=0
fonction occurence(t:tab ; x,n:entier): entier
Debut Si0>0 ? NON
si (n>0) alors
si t[n]=x alors STOP et retourner(0) à la fonction appelante
retourner (1+ occurence(t,x,n-1))
sinon
retourner(occurence(t,x,n-1))

fsi

sinon

retourner(0)

fsi
Fin

Exemple :

T:

2 5 1 5 5

1 2 3 4 5

x:5
Fonction RDP(T:tableau[1..Max]:entier;N:entier):entier
Debut

Si N>0 Alors
Si(T[N]>0)alors
Retourner(N) [16:37] Mazen Mdimegh
Sinon
Retourner(RDP(T,N-1)) fonction ParitéAlterné(T:tab,n:entier) :booléen
FinSi Début
si (n<0)alors
Sinon retourner (vrai)

Retourner(0) sinon
si (t[n]mod2=1) et (t[n-1]mod2=0) alors
Fsi Retourner(ParitéAlterné(T,n-2))
Fin sinon

Retourner (faux

Fsi
Appel initial : RDP(T,9)=8

Si 9>0 ? oui Fsi

Si T[9]>0 ? non Fin

RDP(T,8)=8
 Amira Ben krid
Si 8>0 ? oui
16:39
Si T[8]=7>0 oui

STOP et retourner(8) à la fonction appelante fonction ParitéAlterné(T :tab ; i,n:entier):booléen

debut
si (i<n)
si T[i]mod 2==0 et T[i+1]mod 2!=0 alors
retourner(ParitéAlterné(T,i+2,n))

sinon
retourner (faux)

fsi

sinon

retourner(vrai)

fsi
Fin
  sinon
retourner (faux)

fonction ParitéAlterné(Tableau t ,entier n,... par Mouhamedmarwen.Bensalah fsi

Mouhamedmarwen.Bensalah

16:39 fin si

fonction ParitéAlterné(T :Tab ; n,i :entier):booléen

debut
si(i < n)alors fin
si(i % 2 == 0)alors
si(t[i] %2 != 0) Alors

retourner(faux)

fsi Debut si (i > n) alors Retourn... par Houda BOUZAZI

sinon
si(t[i] %2 == 0) Houda BOUZAZI
retourner(false)
16:44
fsi
Fsi Debut
retourner(ParitéAlterné(t,n,i+1)) si (i > n) alors
sinon Retourner vrai
sinon
Retourner(vrai) si ((T[i] mod 2)==0 et (T[i+1] mod 2)!=0) alors
Fsi Retourner(ParitéAlterné(T,i+2,n)
sinon
Fin Retourner faux
finsi
 Fin

Nouveaux message
fonction parité(t:tab;i:entier) :booleen ... par khouloud jelassi

khouloud jelassi
Séance 2 : suite TD récursivité
fonction parité(t:tab;i,n:entier) :booleen

debut

si(i>n) alors
retourner vrai

sinon
si(t[i] mod 2 ==0 et t[i+1] mod 2 !=0 )alors
retourner (parité(t,i+2,n))
Procedure increment(var t: tab, n: entier)
debut
si (n > 0) alors

si ( t[n] % 2 == 0 ) alors
t[n] = t[n] + n
sinon 1. Fonction Paire :
t[n] = t[n] - n
fin si Fonction Paire (T:TabEntier,i,n:entier):booléen
increment(t,n-1) Debut
fin si si (i<=n) alors
fin si (T[i]mod2)=0 alors
retourner( Paire (T,i+1,n))
sinon
retourner (faux)
Procédure Increment(var T:tableau[1..Max]d'entier;i,N:entier)
Début finsi

Sinon
Si i<=n alors
si (T[i]%2=0)alors Retourner(vrai)
T[i]<-t[i]+i finsi
sinon fin
T[i]<-t[i]-i
Version 2 :
fsi
Fonction Paire(T : TabEntiers, n : entier) : booléen
Incrément(T,i+1,N)
fsi Début
Fin
Si n>0 Alors

Si T[n]mod2 =0 Alors

Retourner (Paire(T, n-1))

Sinon

Retourner (Faux)
 Fsi sinon

Sinon si( t[i] > t[i+1]) alors

Retourner(vrai) retourner (alt(t,n,i+1))
sinon
Fsi retourner(faux)
finsi
Fin

Trace d’exécution : fsi

T: sinon

2 7 8 10
retourner (vrai)

n=4 fsi
Appel initial (version 2) : Paire (T,4)=Faux
fin
Si 4>0 ? oui
Version 2 :
Si T[4] est pair OUI

Paire (T,3)=Faux fonction ALterne(T:tablENtier ; n,i:entier):booléen

début
Si 3>0 ? OUI si (i<n-1) Alors
Si T[3] est pair ? OUI
si (T[i]<T[i+1] et T[i+1]>T[i+2] ) Alors
Pair(T,2)= Faux
retourner (ALterne(T,n,i+2))
Si 2>0 ? OUI
sinon
si T[2] est pair ? NON
retourner (faux)
STOP et retourner « Faux » à la fonction appelante finsi

2. Fonction alterne sinon

si (i=n-1) ALors
si T[i]<T[i+1] ALors
[10:41] mohamed amine ben chiba retourner(vrai)
sinon
fonction alt(t:tab ; n,i:entier):booleen retourner(faux)
fsi
debut sinon
retourner (vrai)
si( i < n) alors fsi
fsi
si i mod 2 =0 alors Fin

si( t[i] < t[i+1]) alors

retourner (alt(t,n,i+1))
sinon 2 7 5 10
retourner(faux)
finsi
Appel initial : Alterne(T,4,1)=vrai retourner (faux)
fin si
fin si
Si 1 <3 ? oui fin
b.
T[1]<T[2] et T[2]>T[3] ? oui

Alterne(T,4,3)=vrai
[11:47] mohamed amine ben chiba
Si 3<3 ? non
si 3=3 ? OUI fonction plindrome(s:chaine de caractere ; i,n:entier):booleen

Si T[3]<T[4] ? OUI debut

STOP et Retourner vrai à la fonction appelante si ( i<n) alors

si( s[i] ==" " ) alors

retourner(palindrome(s,i+1,n))
[11:16] Amyr FEZZENI
sinon
fonction alterne(t: tableau [0..Max] d’entier, i, n : entier): booleen
debut si ( s[n] == " " ) alors
si ( i == n ) alors
retourner(palindrome(s,i,n-1))
retourner vrai
sinon
si ( i % 2 == 0) alors sinon
si (t[i] > t[i+1]) alors
retourner (faux)
si ( s[i] == s[n] ) alors
fin si
sinon retourner (palindrome(s,i+1,n-1))
si (t[i] < t[i+1]) alors sinon
retourner (faux) retourner(faux)
fin si
fin si
retourner alterne(t, i+1, n) finsi
fin si
fin finsi

fsi

sinon

retourner(vrai)

fsi

fin
fonction palindrome(ch : chaine de carractere; i, n: entier) : boolean
debut
si (i >= n) alors
retourner (vrai)
sinon
si (ch[i] == ch[n]) alors
retourner (palaindrome(ch,i+1,n-1))
sinon
 fonction LP(l:Liste): booleen
debut
si (l = nill) alors
Séance 3 : retourner (vrai)
sinon

si (l != nil et l^.next !=nil) alors

retourner LP(l^.next^.next)
sinon
retourner (faux)
fin si
fsi
fin

Appel initial : LP (@0)

Si @0=nil ? non

Si (@0<> nil et @1<>nil ) ? oui

LP(@2)

Si @2=nil ?

Si (@2<> nil et @2^next<>nil)= vrai et faux  faux

Stop et retourner (faux)

[09:28] souha benabid

fonction LP(l:Liste):booleen
debut
si(l=nil) alors
retourner (vrai)
sinon
l: Liste retourner NON( LP(l^.next))
finsi
fin

@0
Appel initial : LP(@0)=faux

2 5 41 Si @0=nil ? non

NON(LP(@0^.next=@1)=vrai)=faux
@1 @2 Nil
Si @1=nil ? non

NON(LP(@1^.next=@2)=faux)=vrai

Si @2=nil ? non

NON(LP(@2^.next=nil)=vrai)=faux

Si nil=nil ? oui
 Stop et retourner vrai Pgcd(x,y)=Local z

z=x

Dérécursivation = suppression de la récursivité = transformer un prog récursif en un prog Tant que y<>0 faire
itératif équivalent.
x=y
1) Récursivité terminale
y=z mod y
Déf : une fct est dite récursive terminale ssi :
fin tq
- Elle contient un seul appel interne
- Elle se termine avec son unique appel interne retourner(x)

Exemples : Palindrome, pgcd

Schéma général : 2) Récursivité non terminale

1.1) Type 1
Condition d’arrêt - Elle contient un seul appel interne
F(x) = si p(x) alors a(x) Traitement associé à la p(x) - Elle ne se termine pas avec son unique appel interne

Sinon Exemple : fonction factorielle

F(b(x)) Transformations à appliquer lors des appels Idée de dérécursivation :

internes
Fsi 1. Etape 1 : introduire une fonction auxiliaire g (exprimée en fonction de f), qui doit être une
fonction récursive terminale
La version itérative équivalente est : 2. Etape 2 : Dérécursiver g
3. Etape 3 : Déduire la version itérative de f à partir de celle de g
F(x)= tant que NON(p(x)) faire
Soit la fonction suivante :
b(x)
Fact(x) = si x =0 alors 1
fintq
Sinon
retourner(a(x))
x*Fact(x-1)
Exemple :
p(x,y) a(x,y) Fsi
Pgcd(x,y) = si y=0 alors x
Objectif : dérécursiver Fact en suivant la démarche précédemment décrite.
Sinon
b(x,y) Etape 1 : introduire une fonction auxiliaire g (exprimée en fact de Fact) et il faut que ça soit
Pgcd(y,x mod y) récursive terminale

Fsi

La fonction Pgcd est récursive terminale. Sa version itérative équivalente :

Soit g(x,y)= y * Fact(x) x=x-1

= si x=0 alors y*1 fin tq

Sinon Fact=y

(y*x)*Fact(x-1) 1.2) Type 2

- Elle contient plusieurs appels internes
fsi
Idée de dérécursivation :utiliser des piles pour la définition de la version itérative.
= si x=0 alors y
Applications :
Sinon

g(x-1,y*x)

fsi

Etape 2 : dérécursivation de g

g est récursive terminale.

1. Puiss(x,n) = si n=0 alors 1
La version itérative de g :
Sinon
x*Puiss(x,n-1)
g(x,y) = tantque x<>0 faire
fsi
2. Puiss est récursive non terminale de type 1.
y=y*x
Démarche de dérécursivation :
x=x-1
Etape 1 : proposer une fct auxiliaire g (en fct de Puiss) et il faut qu’elle soit récursive
fin tq
terminale.
g=y
Soit g(y,x,n)= y*Puiss(x,n)
Etape 3 : déduction de la version itérative de Fact à partir de g
= si n=0 alors y*1
On a : g(x,y)= y * Fact(x)
Sinon
 g(x,y=1)=1*Fact(x)=Fact(x)
y*x*Puiss(x,n-1)
La version iterative de Fact :
fsi
Fact(x)= Local y
= si n=0 alors y
y=1
Sinon
tantque x<>0 faire
g(y*x, x,n-1)
y=y*x
fsi
 g est récursive terminale

Etape 2 : Dérécursivation de g

G étant récursive terminale

g(y,x,n) = si n=0 alors y

Sinon

g(y*x, x,n-1)

fsi

la version itérative de g :

g(y,x,n)= tant que n<>0 faire

y=y*x

n-1
Séance 4 :
fin tq
La fct f est récursive non terminale avec un seul appel.
g=y
La démarche de dérécursivation :
Etape 3 : déduction de la version itérative de Puiss à partir de g
Etape 1 : Introduction d’une fonction auxiliaire g (en fct de f) qui doit être récursive terminale.
On a : g(y,x,n)= y*Puiss(x,n)
On pose g(x,y,a,b)= a*f(x,y)+b
 Puiss(x,n)=g(y=1,x,n)
=si x<y alors a*x+b
Puiss(x,n) = Local y
Sinon
y=1
a*(2*f(x-y,y)+x/y)+b
tant que n<>0 faire
fsi
y=y*x
= si x<y alors a*x+b
n-1
Sinon (2*a)*f(x-y,y)+ (a*(x/y) +b)
fin tq
Fsi
Puiss=y
= si x<y alors a*x+b

Sinon g(x-y,y,2*a, (a*(x/y) +b))

 Fsi Les arbres binaires

Etape 2 : dérécursivation de g AB = ^nœud

g est récursive terminale noeud = enreg

la version itérative de g est : val : valeur

g(x,y,a,b)= tant que x>=y faire fg : AB

b= b+ a*(x/y) fd : AB

x=x-y fenreg

a=2*a

fin tq

retourner(a*x+b)
Fonction Taille(A :AB) : entier
Etape 3 : déduction de la version itérative de f à partir de celle de g
Début
On g(x,y,a,b)=a*f(x,y)+b
Si A=Nil alors
 f(x,y)=g(x,y,a=1,b=0)
Retourner(0)
La version itérative de f :
Sinon
f(x,y) = Local a, b
Retourner(1+Taille(A^.fg) + Taille(A^.fd))
a=1
Fsi
b=0
Fin Appel initial : Taille(@0)=4
tant que x>=y faire
Si @0=nil ? NON
b= b+ a*(x/y) A @0
1+(Taille(A^.fg=Fg1)=2) + (Taille(A^.fd =Fd1)=1)=4

x=x-y 5 Si Fg1=Nil ? non

Fg1 ; Fd1
1+(Taille(Nil)=0)+(Taille(Fd2)=1)=2
a=2*a
1+Taille(nil)+Taille(Nil)=1
fin tq 1 2
Nil ; Fd2 Nil ; Nil

retourner(a*x+b)

9
Nil ; Nil
Fonction Feuille(A:AB) : booléen
Debut Fonction Hauteur(A : AB) :entier
si A=Nil alors
returner (faux) Début
sinon
si (A^.fg=Nil) et (A^.fd=Nil) ) Alors Si A= Nil alors
returner (vrai)
sinon Retourner(0)
returner (faux)
fin si Sinon
fsi
Fin Retourner(1+Max(Hauteur(A^.fg),Hauteur(A^fd))

Fsi

Fin
Fonction NbFeuilles(A :AB) : entier

Début

Si A=Nil alors
[27/09/2021 12:11] Amyr FEZZENI
Retourner(0) Function degenere(A:AB): booléen
début
si (A != nil) alors
Sinon
si (A^.fg != nil et A^.fd != nil)
retourner (faux)
Si A^.fg=Nil ET A^.fd=Nil ALors sinon
retourner (degenere(A^.fg) et degenere(A^.fd))
Retourner(1) fin si
sinon
retourner(vrai)
Sinon fin si
fin
Retourner(NbFeuilles(A^.fg) + NbFeuillez(A^.fd))

Fsi

Fsi

Fin
[09:24] mohamed amine ben chiba Procédure Exchange( var A : AB)

fonction dg(A:AB):booleen Var aux :AB

debut Début

si(A!=nil) alors Si A<> Nil alors

si (A^.fg!=nil et A^.f d!=nil) alors aux= A^.fg

retourner ( faux ) A^.fg= A^.fd

sinon //soit A^.fg = Nil ou A^.fd=Nil A^.fd= aux

si (A^.fg!=nil) alors Exchange(A^.fg)

retourner(dg(A^.fg) ) Exchange(A^.fd)

sinon Fsi

retourner(dg(A^.fd) ) Fin

finsi
sinon

retourner(vrai)
finsi

fin
Les ABR : Applications
finsi
fin

Cette fonction doit retourner vrai si tous les valeurs de tous les nœuds de B sont > à x
fonction parcours_d(B:ABR,x:entier):booleen

debut
@0 [11:10] mohamed amine ben chiba si (B!=nil) alors
A si (B^.val>x) alors
fonction tester(a:AB):booleen retourner(parcours_d(B^.fg,x) et parcours_d(B^.fd,x))
5 sinon
Fg1 ; Fd1 debut retourner(faux)
si (a!=nil) alors finsi
si (Parcours_G(a^.fg , a^.val) Alors sinon
1 7 retourner(vrai)
Nil ; Fd2 Fg3 ; Fd3 si (Parcours_D(a^.fd, a^.val ) )alors
retourner ( tester(a^.fg) et tester(a^.fd) ) finsi
sinon fin
6 6 9 retourner(faux)
Nil ; Nil Nil ; Nil Nil ; Nil
fsi

Procédure Insérer_Rec(var A :ABR, x : entier) Procédure Insérer_It(var A : ABR, x : entier)

sinon
Var Var p :ABR
retourner(faux)
p :ABR
Début Début
Si A=Nil alors
fsi Tant que A<> Nil faire
Créer(p) //Allocation mémoire
p^.val=x Si x<= A^.val alors
sinon
p^.fg=Nil
retourner(vrai)
p^.fd=Nil A= A^.fg
A=p
fsi Sinon
Sinon
fin
Si A^.val>=x alors A= A^.fd
Insérer_rec(A^fg,x)
Sinon Fsi
Cette fonction doit retourner vrai si tous les valeurs de tous les nœuds de B sont <= à x
Insérer_Rec(A^.fd,x)
fonction parcours_g(B:ABR,x:entier):booleen Fin tq
Fsi
Fsi Créer(p) //Allocation mémoire
debut
si (B!=nil) alors p^.val=x
Fin p^.fg=Nil
si (B^.val<=x) alors
retourner(parcours_g(B^.fg,x) et parcours_g(B^.fd,x)) p^.fd=Nil
sinon A=p
retourner(faux) Fin
finsi
sinon
retourner(vrai)
Séance 6 : suite TD

Ls1=^noeud1
Fonction rechercheOcc(A :ABR, x :entier, n : entier) :ABR
Noeud1=enreg
Début
Val : entier
@0 Si A=Nil alors
A
Next : Ls1 Retourner(Nil)
7
Fenreg Fg1 ; Fd1
Sinon

Si x<A^.val Alors
Prédicat d’entrée : A =NIL
5 17 Retourner(rechercheOcc(A^.fg,x,n))
Procédure Construire (l :Ls1, var A : ABR) Fg2 ; Fd2 Fg3 ; Fd3
Sinon
Début
Si l<> Nil alors Si x>A^.val Alors
Insérer_Réc(A,l^.val) 5 6 16 19
Construire(A,l^.next) Retourner(rechercheOcc(A^.fd,x,n))
Nil ; Nil Nil ; Nil Nil ; Nil
Fsi Sinon // A^.val=x
Fin 5
Si n==1 alors

Retourner(A)

Sinon

Retourner(rechercheOcc(A^.fg,x,n-1))

Fsi

Fsi

Fsi

Fin
 fonction Affiche_Arbre(A:ABR)
proc debut
si (A!=nil) alors
retourner ("(" + Affiche_Arbre(A^.fg) + A^.val + Affiche_Arbre(A^.fd)
+ ")")
[11:18] Amyr FEZZENI sinon
procedure croissant(A: ABR) retourner ("_")
@0 debut fin si
A si (A!=nil) alors fin
croissant(A^.fg)
ecrire(A^.val)
7 croissant(A^.fd)
Fg1 ; Fd1
fin si [10:09] Amyr FEZZENI
fin fonction recherche_occu(A:ABR, val, n : entier) : ABR
17 debut
5
si (A!= nil) alors
Fg2 ; Fd2 Fg3 ; Fd3
si (A^.val == val ) alors
n = n-1
si (n == 0) alors
19 retourner (A)
5 6 16
Nil ; Nil Nil ; Nil Nil ; Nil fin si
fsi
5 pro si (val > A^.val) alors
retourner (recherche_occu(A^.fd, val, n))
c sinon
procedure Affiche_arbre(A: ABR)
retourner (recherche_occu(A^.fg, val, n))
debut
fin si
si (A!=nil) alors
sinon
Ecrire(‘’(‘’)
retourner (nill)
Affiche_arbre (A^.fg)
fin si
ecrire(‘’,’’, A^.val, ‘’,’’)
fin
Affiche_arbre (A^.fd)
Ecrire(‘’)‘’)
Sinon
Ecrire(‘’_’’)

fin si
fin
Séance 7 : suppression dans un ABR + les AVLs
Proc update_noeud ( var A:ABR; fils : ABR )
var
P : ABR
Debut
Suppression d’une valeur x d’un ABR A : si fils^.fd != NIL alors
update_noeud(A , fils^.fd)
sinon
1. Localisation du nœud contenant x (s’il existe) A^.val = fils^.val
2. Mise à jour des chaînages P = fils
3. Libération de l’élément ( Libérer(p)) fils = fils^.fg
liberer( P )
fin si
Fin

Le nœud qui contient la valeur x pourra être : Séance 8 : suite les AVLs

1. Un feuille  l’@ de ce nœud sera remplacé par la constante NIL

2. Un nœud avec un seul fils  L’@ de ce nœud sera remplacée par l’@ de son fils unique
3. Un nœud avec 2 fils  le champ valeur du noeud contenant x sera remplacé :
 Soit par la plus grande valeur de son sous arbre gauche
 Soit par la plus petite valeur de son sous arbre droit

[11:30] Amyr FEZZENI

Proc Delete_ABR( var A:ABR ; x : entier)
Debut
si A != NIL alors
si A^.val == x alors
delete_noeud(A)
sinon
si x < A^.val alors
Delete_ABR(A^.fg , x)
sinon
Delete_ABR(A^.fd , x)
fin si
fin si
fin si Dans un AVL, tous les nœuds doivent avoir une mesure de balance appartenant à {1,-1,0}.
Fin
Balance(nœud) =hauteur(fils gauche) – hauteur(fils droit)
Delete_noeud(var A:ABR) Hauteur = max des niveaux
Var P:ABR
Debut
P=A
si A^.fg == NIL alors
A = A^.fd
Libérer(P)
sinon
si A^.fd == NIL alors
A = A^.fg
Libérer(P)
Sinon //les deux fils existent
update_noeud(A , A^.fg)
fin si
fin si
Fin