Exercice 1: Recherche dans un tableau CORRIGE T.D. 2

Université Paris Dauphine Algorithmique et Programmation 2
DE MI2E - 1re année 2014-2015
CORRIGE T.D. 2
Exercice 1: Recherche dans un tableau
Soit Tun tableau de ncellules contenant des valeurs numériques (dont certaines éventuellement iden-
tiques) et soit vune valeur numérique.
1. Ecrire un programme python qui renvoie le plus petit indice itel que T[i] = vou 0 s’il n’en existe
pas (le tableau est parcouru par indice croissant).
2. Donner la complexité de ce programme en fonction de n.
1. def plusPetitIndice (T, v):
for i in range (len (T)):
if T [i] == v:
return i
return -1
T = [1, 5, 0, 13, 3, 5, 7, 9]
print (plusPetitIndice (T, 13))
print (plusPetitIndice (T, 12))
En algorithmique :
PlusPetitIndice(T, n, v) : entier
Entrées : T un tableau, n sa dimension, v une valeur
Sorties : valeur du plus petit indice contenant v ou 0 s’il n’en
existe pas
Données : i:entier
pour i <- 1 à n faire
si v = T[i] alors
retourner i
finsi
finpour
retourner 0
2. Au pire cas : Time(n)≤(1 + 1)n+ 1 = 2n+ 1 d’où Time(n)∈O(n).
Exercice 2: Recherche du plus grand indice
Soit Tun tableau de ncellules contenant des valeurs numériques (dont certaines éventuellement iden-
tiques) et soit vune valeur numérique.

1. Ecrire un programme python qui renvoie le plus grand indice itel que T[i] = vou 0 s’il n’en
existe pas (le tableau est parcouru par indice croissant).
2. Donner la complexité de ce programme en fonction de n.
3. Quel est l’inconvénient de ce programme par rapport au précédent ?
4. La commande "pour indice ←valeur initiale à valeur finale faire" où valeur finale est inférieure
ou égale à valeur initiale réalise des boucles dont l’indice est décroissant. Utiliser cette commande
pour proposer un algorithme plus efficace "symétrique" de l’algorithme de la question 1.
1. def plusGrandIndice (T, v):
indice = -1
for i in range (len (T)):
if T [i] == v:
indice = i
return indice
T = [1, 5, 0, 13, 3, 5, 7, 9]
print (plusGrandIndice (T, 5))
print (plusGrandIndice (T, 12))
en algorithmique :
PlusGrandIndice(T, n, v) : entier
Entrées : T un tableau, n sa dimension, v une valeur
Sorties : valeur du plus grand indice contenant v ou 0 s’il n’en
existe pas
Données : i, indice: entiers
indice <- 0
pour i <- 1 à n faire
si v = T[i] alors
indice <- i
finsi
finpour
retourner indice
2. Au pire cas : Time(n)≤1 + (1 + 1 + 1)n+ 1 = 3n+ 2 d’où Time(n)∈O(n).
3. Nous sommes obligés de parcourir tout le tableau.
4. def plusGrandIndiceDecroissant (T, v):
i = len (T) - 1
while (i > -1):
if T [i] == v:
return i
i = i - 1
return -1
T = [1, 5, 0, 13, 3, 5, 7, 9]
print (plusGrandIndiceDecroissant (T, 5))
print (plusGrandIndiceDecroissant (T, 12))

en algorithmique :
PlusGrandIndice2(T, n, v) : entier
Entrées : T un tableau, n sa dimension, v une valeur
Sorties : valeur du plus grand indice contenant v ou 0 s’il n’en
existe pas
Données : i:entier
pour i <- n à 1 faire
si v = T[i] alors
retourner i
finsi
finpour
retourner 0
Exercice 3: Recherche dans un tableau trié
On suppose maintenant que le tableau T est trié.
1. Ecrire un programme python qui renvoie un indice i(quelconque) tel que T[i] = vou -1 s’il n’en
existe pas. Le principe du programme est le suivant :
(a) Il calcule milieu = (n+ 1)/2et il compare vavec T[milieu]. S’il y a égalité, il renvoie
milieu.
(b) Sinon si v < T [milieu]et milieu > 1, il s’appelle récursivement avec pour entrée la partie
de Tallant de 0 à milieu −1et renvoie le résultat de cet appel.
(c) Sinon si v > T [milieu]et milieu < n, il s’appelle récursivement avec pour entrée la partie
de Tallant de milieu + 1 àn−1et renvoie le résultat de cet appel.
(d) Sinon il renvoie -1 (i.e., pas trouvé).
2. Modifier l’algorithme pour qu’il renvoie le plus petit indice comme dans la question 1.
1. def chercheTableauTrie (T, v, deb, fin):
milieu = (deb+fin)/2
if T [milieu] == v:
return milieu
elif (v > T [milieu] and milieu < len (T) - 1):
return chercheTableauTrie (T, v, milieu+1, fin)
elif (v < T [milieu] and milieu > 0):
return chercheTableauTrie (T, v, deb, milieu-1)
else:
return -1
T = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(chercheTableauTrie (T, 7, 0, len (T) - 1))
print(chercheTableauTrie (T, 10, 0, len (T) - 1))
print(chercheTableauTrie (T, 12, 0, len (T) - 1))

en algorithmique :
Cherche_tableau_trie(T, v, deb, fin) : entier
Entrées : T un tableau trié, v une valeur, deb une borne inf, fin
une borne sup
Sorties : valeur d’un indice contenant v ou 0 s’il n’en
existe pas
Données : milieu: entier
milieu <- (deb+fin)/2
si T[milieu] = v alors
retourner milieu
sinon si v > T[milieu] et milieu < n alors
retourner Cherche_tableau_trie(T, v, milieu+1, fin)
sinon si v < T[milieu] et milieu > 1 alors
retourner Cherche_tableau_trie(T, v, deb, milieu-1)
sinon
retourner 0
finsi
2. def chercheTableauTriePPI (T, v, deb, fin):
milieu = (deb + fin)/2
print (milieu, deb, fin)
if T [milieu] == v:
while T [milieu] == v and milieu > -1:
milieu = milieu - 1
return milieu + 1
elif (v > T [milieu] and milieu < len (T) - 1):
return chercheTableauTriePPI (T, v, milieu+1, fin)
elif (v < T [milieu] and milieu > 0):
return chercheTableauTriePPI (T, v, deb, milieu-1)
else:
return -1
T = [1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 8, 9, 10]
print(chercheTableauTriePPI (T, 7, 0, len (T) - 1))
print(chercheTableauTriePPI (T, 10, 0, len (T) - 1))
print(chercheTableauTriePPI (T, 12, 0, len (T) - 1))

Exercice 4: Complexité de la recherche dans un tableau trié
On étudie la complexité du dernier algorithme.
1. Démontrer que lorsque l’algorithme s’appelle récursivement, la taille du nouveau tableau est in-
férieure ou égale à n/2.
2. Soit T ime(n), le pire temps d’exécution de cet algorithme pour un tableau de taille inférieure ou
égale à n. En déduire que pour une constante cbien choisie :
T ime(1) ≤c
∀n≥2, T ime(n)≤c+T ime(n/2)
3. Démontrer par récurrence que T ime(n)≤c(log2(n)+1) et donc que la complexité de l’algorithme
est en O(log2(n)).
1. Taille du tableau gauche : milieu −1 = n+1
2−1 = n−1 2≤n 2
Taille du tableau droit : n−milieu =n−n+1
2=n−1 2≤n 2
2. Pour n= 1, Time(n)≤13. Au pire cas, on exécute les 13 opérations suivantes :
1er appel:
1 - milieu <- (deb+fin)/2
2 - si T[milieu] = v alors
3 - si v > T[milieu] et
4 - milieu < n alors
5 - sinon si v < T[milieu] et
6 - milieu > 1 alors
2ème appel:
1 - milieu <- (deb+fin)/2
2 - si T[milieu] = v alors
3 - si v > T[milieu] et
4 - milieu < n alors
5 - sinon si v < T[milieu] et
6 - milieu > 1 alors
7 - retourner 0
Pour n≥2, Time(n)≤13+ Time(n
2). Au pire cas, on effectue les opérations suivantes :
1 - milieu <- (deb+fin)/2
2 - si T[milieu] = v alors
3 - si v > T[milieu] et
4 - milieu < n alors
5 - sinon si v < T[milieu] et
6 - milieu > 1 alors
7 - retourner Cherche_tableau_trie_PPI(T, v, deb, milieu-1)
auquel s’ajoute le temps de calcul d’un appel récursif sur un tableau de taille n
2(cf. question 1).