Algorithmique

Durée : 2h

Recherche par dichotomie

Cours Numérique et Sciences Informatiques Page 1 / 5

Capacités attendues
Montrer la terminaison de la recherche dichotomique à l’aide d’un variant de
1
boucle

I – PRÉSENTATION DE L’ALGORITHME..................................................................................................................................... 2
1.1 – APPROCHE NAÏVE....................................................................................................................................................................2
1.2 – APPROCHE PAR DICHOTOMIE.....................................................................................................................................................2
II – COÛT EN TEMPS.............................................................................................................................................................. 3
2.1 – ETUDE DE LA RECHERCHE SÉQUENTIELLE (NAÏVE)...........................................................................................................................4
2.2 – ETUDE DE LA RECHERCHE PAR DICHOTOMIE..................................................................................................................................4
III – TERMINAISON DU PROGRAMME.................................................................................................................................... 5
 Algorithmique
Durée : 2h

Recherche par dichotomie

Cours Numérique et Sciences Informatiques Page 2 / 5

I – Présentation de l’algorithme.
De nos jours, des volumes importants de données sont susceptibles d’être traités par les ordinateurs. Des
algorithmes efficaces sont alors nécessaires pour réaliser ces opérations comme, par exemple, la sélection et la
récupération des données.
Leur rôle est de déterminer si une donnée est présente et, le cas échéant, d’en indiquer sa position, pour
effectuer des traitements annexes. La recherche d’information dans un annuaire illustre cette idée.

1.1 – Approche naïve.

Une première façon de rechercher une valeur dans un tableau est d’effectuer une recherche naïve en
parcourant un à un les éléments.
La fonction « recherche_naive(tab, val) » ci-dessous représente une façon de faire.

1 def recherche_naive(tab, val):

2 for i in range(0, len(tab)):
3 if tab[i] == val:
4 return i
5 return -1

Cet algorithme renvoie un entier positif ou nul en cas de succès, qui correspond à la position de la valeur
recherchée dans le tableau, et -1 en cas d’échec.

Exemple : Déterminer la valeur affichée dans la console lors de l’exécution du programme ci-dessous :

t = [1, 3, 7, 6, 10, 15, 5, 8, 9, 5, 4, 2]

x = 5
print(recherche_naive(t, x))

Valeur affichée dans la console :

1.2 – Approche par dichotomie.

L’idée de cette approche repose sur le principe de réduire de moitié l’espace de recherche à chaque étape. Il
est nécessaire que le tableau soit trié pour utiliser cette méthode.
On regarde la valeur du milieu et si ce n’est pas celle recherchée, on sait qu’il faut continuer de chercher
dans la première moitié ou dans la seconde.

1 On détermine l’élément m au milieu du tableau

2 Si c’est la valeur recherchée, on s’arrête avec un succès.

Sinon, deux cas sont possibles :
 Si m est plus grand que la valeur recherchée, comme le tableau est trié, cela signifie qu’il suffit de
3
continuer à chercher dans la première moitié du tableau ;
 Sinon, il suffit de rechercher dans la moitié droite.
On répète cela jusqu’à avoir trouvé la valeur recherchée, ou bien avoir réduit l’intervalle de recherche
4
à un intervalle vide, ce qui signifie que la valeur recherchée n’a pas été trouvée.
 Algorithmique
Durée : 2h

Recherche par dichotomie

Cours Numérique et Sciences Informatiques Page 3 / 5

Voici un pseudo-code qui recherche par dichotomie un entier v dans une liste triée liste comportant n
éléments.
gauche  0
droite  n-1
TantQue gauche <= droite
milieu = int((gauche+droite)/2)
Si v = liste[milieu] Alors
Renvoyer milieu
Sinon Si liste[milieu] > v Alors
droite  milieu - 1
Sinon
gauche  milieu + 1
Fin Si
Fin TantQue
Renvoyer -1

Analyse de l’algorithme : On souhaite rechercher le nombre 19 dans le tableau ci-dessous :

Liste
1 3 5 6 8 11 13 14 14 17 19 21 23

gauche droite milieu Liste[milieu]

Valeur renvoyée =

II – Coût en temps.
Supposons que l’on doive effectuer une recherche dans un tableau trié contenant beaucoup de valeurs. Il
est évident que l’exécution de cette recherche prendra un certain temps. On appelle cela le coût en temps de
l’algorithme.
Le calcul du coût peut aider au choix d’un algorithme.

Définition : Le coût en temps d’un algorithme est l’ordre de grandeur du nombre d’opérations arithmétiques ou
logiques que doit effectuer un algorithme pour résoudre le problème auquel il est destiné.
Cet ordre de grandeur dépend évidemment de la taille N des données en entrées.
 Coût constant s’il ne dépend pas de N ;
 Coût logarithmique s’il est d’ordre log(N) ;
 Coût linéaire s’il est d’ordre N ;
 Coût quadratique s’il est d’ordre N2 ;
 Coût exponentiel si l’ordre est de la forme d’une puissance ou N apparait en exposant.
 Algorithmique
Durée : 2h

Recherche par dichotomie

Cours Numérique et Sciences Informatiques Page 4 / 5

2.1 – Etude de la recherche séquentielle (naïve).

1 def recherche_naive(tab, val):

2 for i in range(0, len(tab)): Ligne 2 = t1
3 if tab[i] == val: Ligne 3 = test (t2)
4 return i
5 return -1

La ligne 3 est effectuée plusieurs fois. Cela dépend du nombre d’éléments du tableau. On doit toujours ce
placer dans le plus mauvais des cas. L’instruction sera effectuée n-1 fois, si n est le nombre d’éléments du tableau.
Si n=10, alors on pourra avoir la ligne 3 répétée 10 fois. Si n=100, la ligne 3 pourra être répétée 100 fois.
On remarque ici que le nombre de répétitions est proportionnel au nombre n d’éléments.

On a donc un coût linéaire. On dit O(n).

Cela pourra s’avérer pénalisant pour des tableaux comportant beaucoup d’éléments.

2.2 – Etude de la recherche par dichotomie.

Dans la recherche par dichotomie, on regarde la valeur au milieu du tableau trié. Au cas suivant, on
recherche la valeur dans une des moitiés restantes. A chaque boucle, on élimine donc la moitié des valeurs, là où on
en éliminait une seule dans la recherche séquentielle.

Exemple : Si un tableau comporte 174 valeurs, on aura :

Départ It. 1 It. 2 It. 3 It. 4 It. 5 It.6 It. 7 It. 8

174

Le nombre maximum d’itérations sera une puissance de 2.

On a donc un coût logarithmique. On dit O(log n).

 Algorithmique
Durée : 2h

Recherche par dichotomie

Cours Numérique et Sciences Informatiques Page 5 / 5

III – Terminaison du programme.

L’algorithme de recherche contient une boucle non bornée. (Tant Que). Pour être sûr de toujours obtenir un
résultat, il faut s’assurer que le programme se termine, et que l’on ne reste pas bloqué indéfiniment dans la boucle
while.
Pour prouver que c’est bien le cas, nous allons utiliser un variant de boucle.

Variant de boucle : Il s’agit d’une quantité entière qui

 Doit être positive ou nulle pour rester dans la boucle ;
 Doit décroître strictement à chaque itération.

Si l’on arrive à trouver une telle quantité, il est évident que l’on va nécessairement sortir de la boucle au
bout d’un nombre fini d’itérations puisqu’ un entier positif ne peut décroître infiniment.

Preuve de la terminaison :
Dans notre cas, la condition sur la boucle while est : TantQue gauche <= droite.

On peut aussi écrire pour faire apparaitre un variant de boucle : TantQue droite – gauche >= 0.

Notre variant de boucle sera donc la quantité : …………………………

Montrons maintenant que le variant décroit strictement lors de l’exécution du corps de la boucle.

On calcule : milieu = int((gauche+droite)/2). Trois cas sont alors possibles :

 Si v = liste[milieu], on sort de la boucle. La terminaison est assurée.
 Si liste[milieu] >v. On modifie la valeur droite. En appelant droite2 cette nouvelle valeur : droite2 < droite,
donc le variant a strictement décru.
 Sinon, on modifie la valeur gauche. En appelant gauche2 la nouvelle valeur : gauche2 > gauche, donc le
variant a strictement décru.

Le variant ayant strictement décru, nous avons prouvé que notre boucle se termine bien.