Si p1 était une pile bornée, il faudrait que p1 ait au moins 11 valeurs

Informatique TD 3.3 Performances
Lycée Jules Ferry Cannes Page 1 sur 3 TSI2
On a stocké dans une pile un ensemble d’entiers :
p1 = [ 10, 20, 30, 40, 50, 70, 50]
On rappelle que les fonctions de pile disponibles sont :
empiler(p,v), depiler (p), creer_pile(), sommet(p), taille(p) et est_vide().
1) La liste p1 est-elle compatible avec une pile bornée. Justifier votre réponse et proposer un type de
pile compatible.
Si p1 était une pile bornée, il faudrait que p1 ait au moins 11 valeurs
(10 + le nombre de valeurs). Ici la pile ne contient que 7 valeurs, il ne peut
donc s’agir que d’une pile non bornée.
On rappelle l’algorithme de recherche d’un élément x dans une liste non triée L :
def chercher(L,x) :
n = len(L)
s = False
c = 0
while c<n and s==False :
if L[c]==x :
s = c
c = c + 1
return s
On donne les durées d’exécution des instructions suivantes (vraies à 20% près) :
Opération Incrément
boucle for
Affectation
s=10
Opération
(+ –* /)
Test
1==1
Extraction
d’un élément
L[1]
L.append(10) L.pop() len(L)
L : liste de
n éléments
Durée
unitaire(1)
1 0.5 1 1 0.5
1
2
1
(1) la durée unitaire pour l’essai était de 0,1  pour 1000 instructions.
L’incrément i = i+1 est ainsi la somme d’une opération arithmétique et d’une affectation.
2) Quelle est la durée unitaire C(0) d’une boucle avec prise en compte de l’affectation.
C(0) = 5.5 (3 tests + 2 affectations + une extraction + une opération)
3) Donner la complexité C(n) de la fonction chercher (C(n) représente la durée unitaire du traitement de
la liste dans le cas d’une liste en entrée de taille n) :
- donner la valeur de C(n) dans le pire des cas et proposer un appel de la fonction correspondant,
- donner la valeur de C(n) dans le meilleur des cas et proposer un appel de la fonction
correspondant.
C(n) = 5.5* n +2.5 (initialisation) + 2 (dernier test) dans le pire des cas 
chercher(p1, 5) # valeur non présente
C(n) = 9 dans le meilleur des cas  chercher (p1,10) # valeur présente en 1
er
4) Ecrire une fonction rechercher_pile construit sur le même algorithme que chercher mais en utilisant
les fonctions de piles sur une entrée p :
- prévoir un algorithme 1 qui dépile p dans une liste q puis rempile les valeurs dans p,
- prévoir aussi un algorithme 2 qui casse le lien d’alias de p avec la liste appelé et dépile p sans la
rempiler.
Correction en dernière page

Informatique TD 3.3 Performances
Lycée Jules Ferry Cannes Page 2 sur 3 TSI2
Dans la question suivante on exprimera les complexités en nombre d’appels aux fonctions de pile qui
pour simplifier seront supposées de durées d’exécution égales.
5) Donner la complexité de C1(n) et C2(n) dans le pire des cas et conclure sur la complexité de ces 2
algorithmes.
C1(n) = 4 * n +2
C2(n) = n + 1 (le deuxième algorithme est donc 4 fois plus rapide ; la
réaffectation initiale de p dans le deuxième algorithme peut avoir une durée
qui amoindrit cet écart)
6) Ecrire la fonction récursive chercher_rec(L,x) de la fonction chercher (où L est la liste, x est la valeur
cherchée.
def rechercher_rec(L,x) :
n = len(L)
if n == 0 :
return False
elif L[-1]==x :
return n-1
else :
return rechercher (L[ :n-1 ],x)
7) Que renverra :
- rechercher (p1, 50) : 4 ……….………………
- rechercher_rec (p1,50) : 6 …………………………,
8) Déterminer la complexité dans le pire des cas sous forme récursive : Crec(n) = f(Crec(n-1)) en
supposant que l’extraction de plusieurs éléments est similaire au temps pour un seul élément.
Crec(n) = Crec(n-1) + 4.5
9) Déterminer la complexité C(0) et en déduire la complexité de la fonction récursive.
Crec(0) = 2.5
10) Comparer les complexités dans le pire des cas pour les fonctions récursive et itérative.
Crec(n) = 4.5*n+2.5 < 5.5 * n + 2.5 = C(n)
11) Montrer qu’en optimisant la fonction itérative (boucle for + return en milieu de boucle on peut
atteindre une complexité de 3,5*n dans le pire des cas).
def chercher(L,x) :
for c in range (len(L)):
if L[c]==x :
return c
return False