Université Nice Sophia Antipolis Licence Informatique 2 Outils

Université Nice Sophia Antipolis
Outils Formels pour l’Informatique
Licence Informatique 2
2016–2017
TD n˚7
Complexité
Exercice 1)
1. Prouver que n2 + n = O(n2 ).
2. Donner l’ordre de grandeur des expressions suivantes :
n2 + 3n + 1
(a)
n+1
n log(n) + n2 + log(n)2
(b)
n+1
3. Si f (n) en une fonction en O(n), les affirmations suivantes sont-elles vraies ?
(a) (f (n))2 = O(n2 ) ;
(b) 2f (n) = O(2n ).
Exercice 2) Ecrire un algorithme pour calculer pn , qui soit de complexité O(log2 n) (indication : considérer
n écrit en binaire).
Exercice 3) On considère la relation de récurrence :
T (n) = T (n − 1) + T (n − 2) + k
où k est une constante.
1. Donner un exemple d’algorithme dont le temps d’exécution vérifie cette relation.
2. Minorer la complexité d’un tel algorithme.
Exercice 4) Tri à bulle. Soient n nombres rangés dans un tableau A[1..n]. Calculer la complexité de
l’algorithme suivant, dit tri par échange ou tri à bulle, qui remet les éléments de A dans l’ordre croissant
de leur valeur :
procedure BULLE(n : entier ; A : tableau[1..n]de entiers) ;
pour i de n-1 à 1 faire pas -1
pour j de 1 à i faire
si A[j+1] < A[j] alors
ech := A[j] ;
A[j] := A[j+1] ;
A[j+1] := ech ;
finsi
finpour
finpour
finBULLE ;
1
Exercice 5) Déterminer un algorithme qui teste si un tableau de taille n est un “tableau de permutation”
(i.e. tous les éléments sont distincts et compris entre 1 et n).
1. Donner un premier algorithme naı̈f qui soit quadratique.
2. Donner un second algorithme linéaire utilisant un tableau auxiliaire.
Exercice 6) On veut calculer les termes de la suite (un )n∈N définie par :
u0 = 1
un =
un−2
u0
un−1
+
+ ... +
1
2
n
Voici deux programmes qui calculent la valeur de un . Le premier est récursif :
procedure U REC(n : entier) ;
si n = 0 alors
rendre 1 ;
sinon
soit s = 0 dans
pour k de 1 à n pas 1 faire
s := s + U REC(n-k)/k ;
finpour
rendre s ;
finsi
finU REC ;
Le second est itératif :
procedure U ITER(n : entier) ;
soit v = tableau[0..n]de 0 dans
v.(0) := 1 ;
pour i de 1 à n pas 1 faire
pour j de 1 à i pas 1 faire
v.(i) := v.(i) + v.(i-k)/k ;
finpour
finpour
rendre v.(n) ;
finU ITER ;
Comparer la complexité de ces algorithmes.
2