Ce titre assez barbant a sûrement fait fuir plusieurs programmeurs ambitieux (

), mais je peux vous assurer que c'est un concept assez simple à comprendre.
Alors déjà, dans "dichotomie", on peut trouver le mot dictionnaire, et ce n'est pas du tout par hasard.
Je pense que vous avez tous déjà fait une recherche dans un dictionnaire.
Si je vous demande comment on y cherche le mot "chercher", vous allez tous me répondre d'une seule et même voix :
Citation : Quelqu'un ayant déjà cherché dans un dictionnaireOn ouvre le dictionnaire, si on tombe sur une page où les mots commencent par une lettre ultérieure à C, alors on ouvre une autre page entre le début du dictionnaire et la page déjà ouverte ; sinon, on ouvre une autre page entre la page ouverte et la fin.
Et on répète cette opération autant de fois qu'il le faut pour trouver le mot cherché...
Exact, c'est bien cela.
Et c'est exactement la méthode utilisée dans la recherche dichotomique.

Dans un dictionnaire, les mots sont triés, ce qui est forcément une condition pour utiliser ce genre de recherche : le tableau doit impérativement être
trié.
Vous avez plusieurs façons de trier les éléments d'un tableau, et plusieurs tutoriels sur ce site l'expliquent très simplement :
Maintenant que les éléments du tableau sont triés, je vous explique le fonctionnement de l'algorithme, chargé de recherche dichotomique dans un tableau rempli et trié, ceci dans l'ordre croissant
tab[N], avec
min=tab[0] et
max=tab[N].
Comme pour notre recherche dans un dictionnaire, le programme va chercher dans une case au hasard, entre les deux bornes
max et
min. (On prendra leur milieu, pour avoir les mêmes chances des deux côtés.)
Si le nombre trouvé est inférieur au nombre recherché, le programme sait qu'on devra dorénavant le chercher dans la première moitié du tableau. Sinon, on sait maintenant qu'on devra le chercher dans la deuxième moitié.
On refait l'opération pour la moitié concernée, et ainsi de suite jusqu'à tomber sur une moitié qui ne contient qu'une seule case, et là, si notre nombre ne s'y trouve pas, c'est que le nombre n'est pas dans le tableau.
Avouez que vous avez vu plus facile (

), mais ne vous inquiétez pas : si vous n'avez pas compris, vous comprendrez lorsque l'on fera l'implémentation en langage C. La voici, d'ailleurs :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 | /*N est le nombre d'éléments du tableau tab[], contenant des nombres classés par ordre croissant.*/
long nbrRecherche=0, sup=0, inf=0, demi=0, B=1;
printf("Veuillez entrer le nombre recherché : ...");
scanf("%ld", &nbrRecherche)
//On définit les bornes de la partie du tableau à considérer
Sup = N - 1;
Inf = 0;
while(B)
{ /*demi désigne l'indice de l'élément à comparer. En bonne rigueur, il faudra veiller à ce que demi soit bien un nombre entier, ce qui pourra s'effectuer de différentes manières selon les langages.*/
demi = (sup + inf)/2;
/*Si le nombre se situe avant le point de comparaison, alors la borne supérieure change, la borne inférieure ne bouge pas.*/
if(nbrRecherche < tab[demi])
{
sup = demi - 1;
}
/*Sinon, c'est l'inverse*/
else
{
inf = demi + 1
}
if( sup<inf || nbrRecherche=tab[demi])
{
B=0
}
}
if{nbrRechercher == tab[demi]}
{
printf("Le nombre %ld se trouve dans la case n°%ld" nbrRecherche, demi+1);
}
else
{
printf("Le nombre %ld ne se trouve pas dans ce tableau", nbrRecherche);
}
|
Par comparaison entre la recherche dichotomique et la recherche séquentielle, prenons l'exemple de tout à l'heure (un nombre qui ne se trouve pas dans la liste) :
Code : Console | 12 24 35 48 57 61 70 79 83 85 87 96 99 101 412 931 |
Et faisons la trace du programme (le compte rendu de ses actions, si vous voulez

), et ce en cherchant le nombre 835 qui ne se trouve pas dans la liste.
- 1er tour de boucle : la liste contient 16 cases. Donc inf=0 et sup=15, et demi=7. La case n°7 est occupée par le nombre 79, qui est différent de 835 ; on a alors inf=demi+1=8.
- 2e tour de boucle : inf=8 et sup=15, et demi=11. La case n°11 est occupée par 96, qui est différent de 835 ; on a alors inf=demi+1=12.
- 3e tour de boucle : inf=12 et sup=15, et demi=13. La case n°13 est occupée par 101, qui est différent de 835 ; on a alors inf=demi+1=14.
- 4e : inf=14 et sup=15, et demi=14. La case n°14 est occupée par 412, qui est différent de 835 ; on a alors inf=demi+1=15.
- 5e tour de boucle : inf=15 et sup=15, et demi=15. La case n°15 est occupée par 931, qui est différent de 835 ; on a alors sup=demi-1=14.
- 6e tour de boucle : on a inf>sup, donc le programme écrit à l'écran :Code : Console
| Le nombre 835 ne se trouve pas dans ce tableau |
Et voilà : on peut remarquer que le programme a fait 6 tours de boucle pour savoir que le nombre recherché ne se trouve pas dans le tableau, contre 16 tours de boucle pour la recherche séquentielle.
Sauf que le problème avec cet algorithme, c'est que le tableau doit impérativement être trié auparavant.

Mais il trouvera bien son utilité dans la recherche du mot "zéro", dans un dictionnaire de 50 000 mots par exemple.
