$course$/QCM de NSI/Première/Recherche dichotomique Recherche dichotomique dans une liste triée, principe
d'élimination de la moitié, calcul du milieu, indices
gauche/droite, coût logarithmique, implémentation
itérative, terminaison à l'aide d'un variant de boucle,
pièges classiques (bornes, doublons).

]]> Recherche dichotomique — Q01 : Principe Quel est le principe de la recherche dichotomique ?

]]> « Dichotomie » vient du grec « di » (deux) +
« tomos » (couper) : couper en deux. À chaque
étape, on coupe l'intervalle de recherche par
deux.

]]> 1.0 0.0 0 true true abc Trier la liste avant chaque comparaison

]]> Erreur : la liste doit être triée avant
la recherche, pas pendant.

]]> Utiliser un dictionnaire

]]> Erreur : c'est une autre stratégie (table
de hachage), pas la dichotomie.

]]> Parcourir la liste élément par élément

]]> Erreur : c'est la recherche linéaire.

]]> Comparer la cible à l'élément du milieu, puis répéter sur la moitié appropriée

]]> Bonne réponse : à chaque étape, on élimine
la moitié de la liste, ce qui donne une
complexité logarithmique.

]]> Recherche dichotomique — Q02 : Précondition La recherche dichotomique exige-t-elle une
condition particulière sur la liste ?

]]> Si la liste n'est pas triée, on ne peut pas
conclure qu'un élément cherché se trouve « avant »
ou « après » le milieu. C'est l'hypothèse-clé.

]]> 1.0 0.0 0 true true abc La liste doit être de taille au moins 100

]]> Erreur : aucune condition de taille minimale.

]]> La liste doit être de longueur paire

]]> Erreur : la dichotomie fonctionne sur
n'importe quelle longueur.

]]> La liste doit contenir uniquement des entiers

]]> Erreur : la dichotomie fonctionne sur tout
type comparable (entiers, flottants, chaînes).

]]> La liste doit être triée

]]> Bonne réponse : c'est la condition
essentielle. Sans tri, la comparaison au
milieu ne permet pas de savoir dans quelle
moitié chercher.

]]> Recherche dichotomique — Q03 : Complexité Quelle est la complexité dans le pire cas de
la recherche dichotomique ?

]]> Pour 10⁶ éléments : ~ 20 comparaisons. Pour 10⁹
éléments : ~ 30 comparaisons. La dichotomie
passe à l'échelle remarquablement.

]]> 1.0 0.0 0 true true abc O(1)

]]> Erreur : on doit faire plusieurs comparaisons
dans le pire cas.

]]> O(n log n)

]]> Erreur : c'est la complexité du tri (par
fusion ou rapide), pas de la recherche.

]]> O(log n)

]]> Bonne réponse : à chaque étape on divise
l'intervalle par 2, donc le nombre d'étapes
est log₂(n).

]]> O(n)

]]> Erreur : c'est la complexité de la recherche
linéaire.

]]> Recherche dichotomique — Q04 : Calcul du milieu Avec deux indices g (gauche) et d (droite),
comment calcule-t-on l'indice du milieu en
Python ?

]]> Variante équivalente :
m = g + (d - g) // 2. C'est plus robuste sur
certains langages où g + d peut déborder, mais
en Python (entiers de précision arbitraire),
(g + d) // 2 suffit.

]]> 1.0 0.0 0 true true abc m = (g + d) // 2

]]> Bonne réponse : moyenne entière des deux
indices. Le // (division entière) garantit
un indice valide.

]]> m = g - d

]]> Erreur : différence, pas milieu.

]]> m = g + d

]]> Erreur : ce n'est pas le milieu, c'est la
somme.

]]> m = (g + d) / 2

]]> Erreur : / produit un flottant en
Python 3, qui ne peut pas servir d'indice.

]]> Recherche dichotomique — Q05 : Élimination de moitié Si la valeur à l'indice du milieu est plus
petite que la cible (et la liste est triée
croissant), où chercher ensuite ?

]]> Dans le code itératif, on fait g = m + 1 (et
non g = m, sinon boucle infinie possible).

]]> 1.0 0.0 0 true true abc Dans la moitié droite

]]> Bonne réponse : si le milieu est plus petit
que la cible, alors toutes les valeurs à
gauche le sont aussi (liste triée). On peut
les éliminer.

]]> Dans la moitié gauche

]]> Erreur : à gauche, les valeurs sont encore
plus petites (liste triée croissant).

]]> Dans toute la liste

]]> Erreur : l'intérêt de la dichotomie est
précisément d'éliminer la moitié.

]]> Au milieu, à nouveau

]]> Erreur : on resterait sur la même valeur
indéfiniment (boucle infinie).

]]> Recherche dichotomique — Q06 : Code itératif Quel code implémente correctement la recherche
dichotomique itérative (renvoie l'indice ou -1) ?

]]> Trois mises à jour d'indices selon la
comparaison : égal (trouvé), inférieur (chercher
à droite), supérieur (chercher à gauche).

]]> 1.0 0.0 0 true true abc `python
def dicho(liste, cible):
g, d = 0, len(liste)
while g < d:
m = (g + d) // 2
if liste[m] == cible:
return m
g = m
d = m
return -1
`

]]> Erreur : g = m et d = m ne réduisent pas
l'intervalle. Boucle infinie possible.

]]> `python
def dicho(liste, cible):
for x in liste:
if x == cible:
return x
return -1
`

]]> Erreur : c'est de la recherche linéaire,
pas dichotomique. Et on renvoie la valeur,
pas l'indice.

]]> `python
def dicho(liste, cible):
g, d = 0, len(liste) - 1
while g <= d:
m = (g + d) // 2
if liste[m] == cible:
return m
elif liste[m] < cible:
g = m + 1
else:
d = m - 1
return -1
`

]]> Bonne réponse : structure classique avec deux
indices, mise à jour m + 1 ou m - 1 pour
éviter les boucles infinies, retour -1 si
la cible est absente.

]]> `python
def dicho(liste, cible):
return liste.index(cible)
`

]]> Erreur : list.index fait une recherche
linéaire en interne, et lève une
exception si absente.

]]> Recherche dichotomique — Q07 : Sortie de boucle Dans le code itératif while g <= d:, quand la
boucle se termine-t-elle si la cible est absente ?

]]> C'est la condition d'arrêt « propre » : tant
qu'il reste au moins un élément candidat
(g <= d), on continue ; sinon, élément absent.

]]> 1.0 0.0 0 true true abc Quand g == d

]]> Erreur : g == d satisfait encore g <= d,
la boucle continue.

]]> Au bout de 10 itérations

]]> Erreur : aucune limite fixe d'itérations.

]]> Quand g > d (les deux indices se sont croisés)

]]> Bonne réponse : à chaque échec, l'intervalle
rétrécit. Quand il devient vide (g > d), on
sort et on renvoie -1.

]]> Quand on rencontre une exception

]]> Erreur : un code correct ne lève pas
d'exception.

]]> Recherche dichotomique — Q08 : Liste vide Que renvoie la dichotomie sur une liste vide ?

]]> Cas limite à toujours tester. Bonne pratique :
assert dicho([], 5) == -1.

]]> 1.0 0.0 0 true true abc None

]]> Selon notre convention, on renvoie -1 (pas
None).

]]> Une exception

]]> Erreur : le code correct gère ce cas
proprement.

]]> -1

]]> Bonne réponse : g = 0, d = -1, donc
g > d immédiatement. La boucle ne s'exécute
pas et la fonction renvoie -1 directement.

]]> 0

]]> Erreur : aucune position 0 dans une liste
vide.

]]> Recherche dichotomique — Q09 : Pourquoi dichotomique ? Quel est le principal avantage de la
dichotomique sur la linéaire ?

]]> Mais attention : si la liste n'est pas triée et
qu'on la trie juste pour la dichotomie, le tri
coûte O(n log n). Pour une seule recherche,
la linéaire est plus rapide.

]]> 1.0 0.0 0 true true abc Elle est plus simple à programmer

]]> Au contraire, elle est légèrement plus
complexe (gestion des indices).

]]> Elle utilise moins de mémoire

]]> Pas un avantage notable : les deux utilisent
peu de mémoire.

]]> Elle ne nécessite pas que la liste soit triée

]]> Erreur : c'est la précondition
fondamentale.

]]> Elle est exponentiellement plus rapide sur les listes triées de grande taille

]]> Bonne réponse : passer de O(n) à O(log n)
est un gain énorme. 1 milliard d'éléments :
1 milliard de comparaisons en linéaire vs
~ 30 en dichotomique.

]]> Recherche dichotomique — Q10 : Trace simple On cherche cible = 17 dans
liste = [3, 7, 11, 17, 25, 31, 42]. Quel est
l'indice du milieu à la première étape ?

]]> Ici, la dichotomie est miraculeusement efficace
parce que la cible se trouve juste au milieu.
Cas favorable : O(1).

]]> 1.0 0.0 0 true true abc 4

]]> Erreur : (0 + 6) // 2 = 3, pas 4.

]]> 6

]]> Erreur : 6 est l'indice droit, pas le
milieu.

]]> 3

]]> Bonne réponse : g = 0, d = 6, milieu =
(0 + 6) // 2 = 3. La valeur en indice 3 est
17, qui est la cible : la dichotomie
réussit en une seule comparaison.

]]> 0

]]> Erreur : 0 est l'indice gauche, pas le
milieu.

]]> Recherche dichotomique — Q11 : Invariant de boucle Quel invariant de boucle garantit la
correction de la recherche dichotomique
itérative (avec les indices g et d) ?

]]> Invariant + condition d'arrêt → correction.
À la sortie de la boucle, soit on a trouvé
la cible, soit g > d (intervalle vide,
donc la cible n'est pas dans la liste).

]]> 1.0 0.0 0 true true abc La cible est toujours à l'indice du milieu

]]> Erreur : sinon la dichotomie réussirait
en une seule comparaison.

]]> La liste est triée

]]> Erreur : ce n'est pas un invariant de la
boucle, c'est une précondition sur
l'entrée.

]]> Si la cible est dans la liste, alors elle se trouve nécessairement dans la tranche liste[g..d] (notation algorithmique inclusive des deux côtés ; en Python : liste[g:d+1])

]]> Bonne réponse : c'est l'invariant clé. À
l'entrée de chaque itération, la cible
(si elle existe) est forcément dans la
tranche encore considérée. Si l'on
n'élimine que la moitié sans la cible,
l'invariant reste vrai à la sortie.

]]> g et d sont toujours égaux

]]> Erreur : ils ne deviennent égaux qu'à la
dernière itération (au plus tard).

]]> Recherche dichotomique — Q12 : Doublons Si la cible apparaît plusieurs fois dans la
liste triée, quelle position renvoie la
dichotomie standard ?

]]> Pour obtenir spécifiquement la première
ou la dernière occurrence en cas de
doublons, on adapte légèrement le code de
la dichotomie (en continuant à chercher à
gauche ou à droite après une égalité, au
lieu de s'arrêter).

]]> 1.0 0.0 0 true true abc Une occurrence quelconque (la première rencontrée pendant la dichotomie)

]]> Bonne réponse : la dichotomie standard ne
précise pas laquelle. Pour avoir la
première ou la dernière occurrence,
il faut une variante (continuer la
dichotomie même après avoir trouvé).

]]> La dernière occurrence (à droite)

]]> Possible mais non garanti.

]]> Toutes les occurrences

]]> Erreur : la dichotomie renvoie un seul
indice.

]]> La première occurrence (à gauche)

]]> Possible mais non garanti : dépend du
parcours.

]]> Recherche dichotomique — Q13 : Trace détaillée On cherche cible = 25 dans
liste = [3, 7, 11, 17, 25, 31, 42]. Combien de
comparaisons effectue la dichotomie itérative
avant de trouver la cible ?

]]> Pour log₂(7) ≈ 2,8, on attend au plus 3
comparaisons. C'est cohérent.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : la cible n'est pas en indice 3.

]]> 7

]]> Erreur : c'est le nombre d'éléments, pas
de comparaisons.

]]> 2

]]> Bonne réponse : étape 1, milieu = 3 (val
17 < 25, on va à droite, g=4) ; étape 2,
milieu = (4+6)//2 = 5 (val 31 > 25, on va à
gauche, d=4) ; étape 3, milieu = 4 (val 25
= cible). En réalité 3 comparaisons, mais 2
décisions de moitié.

Note : si la question demande « comparaisons »
au sens « tests d'égalité », c'est 3 ; au
sens « décisions de moitié », c'est 2.

]]> 3

]]> Cette réponse compte les comparaisons
d'égalité (3, 17, 25). Selon
l'interprétation, c'est aussi correct, mais
le compte par décisions de moitié donne 2.

]]> Recherche dichotomique — Q14 : Élément absent On cherche cible = 20 dans
liste = [3, 7, 11, 17, 25, 31, 42]. Que
renvoie la dichotomie ?

]]> Pour trouver « la valeur la plus proche » ou
« la position d'insertion », il faut adapter
légèrement le code de la dichotomie : au
moment où l'on sortirait avec -1, on
renvoie plutôt l'indice où la cible aurait
dû s'insérer.

]]> 1.0 0.0 0 true true abc Une exception

]]> Erreur : code correct gère le cas absent.

]]> L'indice 4 (position où 20 devrait être inséré)

]]> Erreur : ce serait le rôle d'une variante
(« position d'insertion ») qui demande une
adaptation du code. La dichotomie standard
renvoie -1 quand l'élément est absent.

]]> La valeur 17 (la plus proche)

]]> Erreur : la dichotomie ne renvoie pas la
« valeur la plus proche » par défaut.

]]> -1 (élément absent)

]]> Bonne réponse : 20 n'est pas dans la liste.
La boucle se termine avec g > d et
renvoie -1.

]]> Recherche dichotomique — Q15 : Bug de bornes Un élève écrit while g < d: au lieu de
while g <= d:. Quel est l'effet ?

]]> Toujours tester les cas limites : liste à
un seul élément, cible aux extrémités, cible
non présente. Ces tests révèlent les bugs de
bornes.

]]> 1.0 0.0 0 true true abc La fonction est plus rapide

]]> Erreur : juste incorrecte.

]]> La fonction renvoie toujours -1

]]> Erreur : elle peut renvoyer un indice si la
cible est trouvée avant le rétrécissement
final.

]]> La fonction rate la cible quand elle est en position telle que g == d à la fin

]]> Bonne réponse : si l'intervalle se réduit à
un seul élément (g == d), la condition
g < d est fausse et on sort sans tester
ce dernier élément. Bug subtil mais courant.

]]> Boucle infinie

]]> Pas de boucle infinie, mais un bug logique.

]]> Recherche dichotomique — Q16 : Indice retourné en cas de succès Une dichotomie standard sur la liste
[3, 7, 11, 17, 25, 31, 42] cherche cible = 17.
Que renvoie-t-elle ?

]]> Convention courante : la fonction renvoie
l'indice de la cible quand elle est
trouvée, et -1 (ou parfois None) quand
elle est absente. La méthode list.index
de Python lève une exception ValueError à
la place du -1.

]]> 1.0 0.0 0 true true abc L'indice 3

]]> Bonne réponse : la valeur 17 se trouve
en position 3 dans la liste (positions
0 à 6). Une dichotomie standard
renvoie cet indice quand la cible est
présente.

]]> La longueur de la liste, c'est-à-dire 7

]]> Erreur : la longueur de la liste n'a aucun
rapport avec la position de la cible. On
renvoie -1 (par convention) seulement
si la cible est absente.

]]> La position 0 (la première de la liste)

]]> Erreur : la position 0 correspond à la
valeur 3, pas à 17. La dichotomie
renvoie l'indice exact de la cible
trouvée.

]]> La valeur 17

]]> Erreur : la fonction renvoie l'indice
de la cible, pas sa valeur (qu'on connaît
déjà puisqu'on la passe en paramètre).

]]> Recherche dichotomique — Q17 : Liste à un élément Sur liste = [42] et cible = 42, combien
d'itérations effectue la dichotomie standard ?

]]> Cas limite à tester. Si la cible n'était pas 42
mais autre chose, on aurait besoin de 1 ou 2
itérations selon les détails du code.

]]> 1.0 0.0 0 true true abc 1 (une seule itération suffit)

]]> Bonne réponse : g = 0, d = 0, donc
g <= d. Une itération calcule m = 0,
compare liste[0] et trouve la cible.

]]> 0 (la cible est trouvée sans entrer dans la boucle)

]]> Erreur : on entre bien dans la boucle pour
tester la valeur du milieu.

]]> 2

]]> Erreur : une itération suffit.

]]> Boucle infinie

]]> Erreur : code correct se termine.

]]> Recherche dichotomique — Q18 : Tri préalable utile ? On a une liste non triée de 1000 éléments
sur laquelle on doit faire une seule
recherche. Faut-il la trier avant pour faire de
la dichotomie ?

]]> Règle : tri rentable si l'on fait au moins ~ k
recherches, avec k tel que n log n + k log n
< k n. Approximativement k > log n.

]]> 1.0 0.0 0 true true abc Oui, parce que dichotomique = mieux

]]> Erreur : « mieux » dépend du contexte. Coût
de tri à amortir.

]]> Oui, c'est plus rapide

]]> Erreur : trier coûte O(n log n) ≈ 10 000
opérations, plus 10 pour la dichotomie. La
recherche linéaire ne fait au plus que
1 000 comparaisons. Pas rentable.

]]> La dichotomie fonctionne sur une liste non triée

]]> Erreur : la précondition est essentielle.

]]> Non, la recherche linéaire suffit pour une recherche unique

]]> Bonne réponse : trier juste pour une
recherche est contre-productif. La
dichotomie devient rentable seulement à
partir de plusieurs recherches sur la
même liste.

]]> Recherche dichotomique — Q19 : Recherche par approximation Pour trouver la plus petite valeur ≥ cible
dans une liste triée, peut-on utiliser une
dichotomie ?

]]> C'est l'un des grands intérêts de la
dichotomie : elle s'adapte à toutes sortes de
requêtes (≤, <, ≥, >) sur des données triées.

]]> 1.0 0.0 0 true true abc Oui, mais cela double la complexité

]]> Erreur : la complexité reste O(log n).

]]> Non, la dichotomie ne fonctionne que pour des comparaisons d'égalité

]]> Erreur : la dichotomie repose sur des
comparaisons d'ordre, pas d'égalité.

]]> Non, cela demande une recherche linéaire

]]> Erreur : la dichotomie peut être adaptée.

]]> Oui, en adaptant légèrement le code de la dichotomie

]]> Bonne réponse : il suffit de continuer à
chercher dans la moitié gauche après une
égalité (au lieu de s'arrêter), pour
retomber sur la plus petite valeur ≥
cible. La complexité reste O(log n).

]]> Recherche dichotomique — Q20 : Terminaison Pourquoi la dichotomie itérative se termine
toujours (pas de boucle infinie) ?

]]> Argument de terminaison : on définit un
« variant » qui décroît strictement (ici,
d - g). Si le variant est borné inférieurement
(ici, par 0 ou -1), la boucle se termine.

]]> 1.0 0.0 0 true true abc Parce qu'à chaque itération, l'intervalle [g, d] se rétrécit strictement

]]> Bonne réponse : g = m + 1 ou d = m - 1
réduit la taille de l'intervalle d'au moins
un. L'intervalle ne peut donc rétrécir
indéfiniment, il finit par devenir vide
(g > d).

]]> Parce que Python limite les boucles à 1000 itérations

]]> Erreur : Python n'impose aucune telle limite.

]]> Parce que la cible est forcément trouvée

]]> Erreur : la cible peut être absente, et la
dichotomie se termine quand même.

]]> Parce que la liste est triée

]]> Erreur : le tri permet la correction, pas
la terminaison.

]]> Recherche dichotomique — Q21 : Boucle infinie Un élève écrit g = m (au lieu de g = m + 1)
après une comparaison liste[m] < cible. Que se
passe-t-il ?

]]> Bug très classique. Test à faire :
dicho([1, 2], 2) qui doit renvoyer 1. Avec le
bug, boucle infinie.

]]> 1.0 0.0 0 true true abc La fonction est plus rapide

]]> Erreur : elle peut boucler indéfiniment.

]]> La fonction lève une exception

]]> Erreur : pas d'exception, juste une boucle
infinie.

]]> La fonction renvoie toujours -1

]]> Pas systématiquement : selon l'entrée, soit
elle trouve la cible, soit elle boucle.

]]> Boucle infinie possible si g + d est pair (donc m == g)

]]> Bonne réponse : si g = 0, d = 1, alors
m = 0. Si on fait g = m, on reste à
g = 0, et la boucle ne progresse pas.
D'où l'importance d'écrire g = m + 1.

]]> Recherche dichotomique — Q22 : Trace pas à pas On cherche cible = 2 dans
liste = [1, 2, 3, 4, 5, 6, 7, 8] (n=8). Quels
sont les indices m successivement testés par
la dichotomie itérative ?

]]> Méthode : noter g, d, m à chaque étape,
mettre à jour les bornes selon la comparaison,
s'arrêter dès qu'on trouve la cible.

]]> 1.0 0.0 0 true true abc 3, 1, 2

]]> Erreur : la fonction renvoie dès qu'elle
trouve la cible (à m=1). Elle ne teste pas
ensuite l'indice 2.

]]> 4 puis 2

]]> Erreur : (0+7)//2 = 3, pas 4. Le calcul
du milieu utilise la division entière.

]]> 3 puis 1

]]> Bonne réponse : étape 1, g=0,d=7,m=3
(liste[3]=4 > 2, on va à gauche : d=2) ;
étape 2, g=0,d=2,m=1 (liste[1]=2 = cible,
retour immédiat de l'indice 1). Deux indices
testés.

]]> 0, 1, 2 (parcours du début)

]]> Erreur : ce serait une recherche linéaire.
La dichotomie commence par le milieu.

]]> Recherche dichotomique — Q23 : Variant de boucle Quel est le variant de boucle (quantité qui
décroît strictement) de la dichotomie ?

]]> Notion de variant : indispensable pour prouver
la terminaison d'une boucle. La taille de
l'intervalle est l'exemple canonique pour la
dichotomie.

]]> 1.0 0.0 0 true true abc La valeur du milieu m

]]> Erreur : m peut augmenter ou diminuer selon
la comparaison.

]]> La cible

]]> Erreur : la cible ne change pas pendant la
recherche.

]]> L'indice g

]]> Erreur : g peut rester constant si on met
à jour seulement d.

]]> La taille de l'intervalle de recherche, d - g + 1

]]> Bonne réponse : c'est précisément cette
quantité qui décroît strictement à chaque
itération (et même elle est divisée par 2
en moyenne). Quand elle atteint 0, on sort
de la boucle.

]]> Recherche dichotomique — Q24 : Recherche en mémoire externe On dispose d'un fichier trié de 10 milliards
d'enregistrements (sur disque). Quel impact
pratique a la dichotomie ?

]]> Idée centrale : à chaque étape, on divise
l'intervalle de recherche par deux. C'est ce
qui donne le coût logarithmique.

]]> 1.0 0.0 0 true true abc Cela ne fonctionne pas hors mémoire vive

]]> Erreur : la dichotomie ne nécessite pas de
tout charger en mémoire. C'est même son
intérêt.

]]> 10 milliards d'accès disque sont nécessaires

]]> Erreur : ce serait la linéaire, donc plusieurs
jours de calcul.

]]> Aucun, la lecture séquentielle est aussi rapide

]]> Erreur : avec 10 milliards d'enregistrements,
la lecture séquentielle est très lente.

]]> ~ 34 accès disque suffisent (log₂(10¹⁰) ≈ 33,2)

]]> Bonne réponse : la dichotomie permet de
consulter une base gigantesque en très peu
d'accès. C'est ce qui permet aux moteurs de
recherche, BDD et autres systèmes
d'indexer efficacement de gros volumes.

]]> Recherche dichotomique — Q25 : Synthèse Parmi les affirmations suivantes sur la
recherche dichotomique, laquelle est fausse ?

]]> Aucun algorithme universellement supérieur :
la dichotomie est très puissante mais a ses
conditions d'application (tri, taille
suffisante).

]]> 1.0 0.0 0 true true abc Sa complexité est O(log n)

]]> Vrai : c'est sa caractéristique fondamentale.

]]> Elle ne fonctionne que sur des listes triées

]]> Vrai : c'est la précondition essentielle.

]]> Des variantes adaptées du code permettent de localiser la première ou la dernière occurrence en cas de doublons

]]> Vrai : il suffit, après une égalité, de
continuer à chercher à gauche (pour la
première occurrence) ou à droite (pour
la dernière) au lieu de s'arrêter. La
complexité reste O(log n).

]]> Elle est toujours plus rapide que la recherche linéaire

]]> Faux (donc bonne réponse) : pour une seule
recherche dans une liste non triée,
trier puis dichotomiser coûte plus cher que
la linéaire. Et sur des très petites listes
(< 10 éléments), la différence est
négligeable.

]]> Recherche dichotomique — Q26 : Version récursive Quel code implémente correctement une version
récursive de la recherche dichotomique
(renvoie l'indice ou -1) ?

]]> Avantage de la version récursive : code plus
court, qui suit naturellement le raisonnement
« diviser pour régner ». Inconvénient : risque
de dépassement de pile pour de très grandes
listes (Python limite la profondeur à environ
1000), ce qui n'est jamais un souci ici car la
profondeur reste en log₂(n).

]]> 1.0 0.0 0 true true abc `python
def dicho(liste, cible, g, d):
if g >= d:
return -1
m = (g + d) // 2
if liste[m] == cible:
return m
return dicho(liste, cible, g, d)
`

]]> Erreur double : le cas de base g >= d rate
la cible quand l'intervalle se réduit à un
seul élément (cas similaire au bug while g < d:),
et l'appel récursif sans mise à jour de
g, d provoque une récursion infinie si la
cible n'est pas en milieu.

]]> `python
def dicho(liste, cible, g, d):
if g > d:
return -1
m = (g + d) // 2
if liste[m] == cible:
return m
elif liste[m] < cible:
return dicho(liste, cible, m + 1, d)
else:
return dicho(liste, cible, g, m - 1)
`

]]> Bonne réponse : cas de base g > d (intervalle
vide), sinon trois cas selon la comparaison
au milieu. La récursion porte sur des bornes
mises à jour, exactement comme dans la version
itérative.

]]> `python
def dicho(liste, cible, g, d):
m = (g + d) // 2
if liste[m] == cible:
return m
elif liste[m] < cible:
return dicho(liste, cible, m + 1, d)
else:
return dicho(liste, cible, g, m - 1)
`

]]> Erreur : il manque le cas de base. Quand la
cible est absente, l'intervalle se rétrécit
jusqu'à devenir vide (g > d), puis on
accède à liste[m] avec un indice invalide,
ce qui peut lever une exception ou faire une
récursion infinie.

]]> `python
def dicho(liste, cible):
if len(liste) == 0:
return -1
m = len(liste) // 2
if liste[m] == cible:
return m
elif liste[m] < cible:
return dicho(liste[m+1:], cible)
else:
return dicho(liste[:m], cible)
`

]]> Erreur : le découpage par tranche
liste[m+1:] recopie une partie de la liste
(coût O(n) à chaque appel), ce qui ruine
l'avantage de la dichotomie. De plus, l'indice
renvoyé est relatif à la sous-liste, donc
incorrect par rapport à la liste originale.

]]> Recherche dichotomique — Q27 : Doublement de la taille Une recherche dichotomique sur une liste de
taille n effectue au pire k comparaisons.
Combien de comparaisons effectue-t-elle au pire
sur une liste de taille 2n ?

]]> Lecture pratique : on peut multiplier par mille
la taille d'une liste sans payer plus de dix
comparaisons supplémentaires (log₂(1000) ≈ 10).
C'est ce qui rend la dichotomie incontournable
pour les très gros volumes.

]]> 1.0 0.0 0 true true abc 2k

]]> Erreur : la dichotomie n'est pas linéaire en
n. Doubler la taille n'ajoute pas k
comparaisons mais une seule.

]]> k

]]> Erreur : ce serait dire que la complexité ne
dépend pas de la taille, ce qui est faux. La
dichotomie ajoute bien une comparaison
quand on double n.

]]> k + 1

]]> Bonne réponse : la complexité est en
log₂(n). Or log₂(2n) = log₂(n) + 1. Donc
doubler la taille n'ajoute qu'une seule
comparaison au pire. C'est la signature
fondamentale d'un algorithme logarithmique.

]]> k²

]]> Erreur : il n'y a pas de carré dans
log(2n). Cela donnerait une complexité
beaucoup trop élevée.

]]> Recherche dichotomique — Q28 : Dichotomie de frontière On dispose d'une liste triée de booléens (par
exemple [False, False, False, True, True, True])
et on cherche l'indice de la première
occurrence de True. Quel principe permet de
résoudre ce problème en O(log n) ?

]]> Schéma général : si P(i) est une propriété
monotone sur i (par exemple : « la valeur en
position i est True »), on trouve la
frontière en O(log n) par dichotomie. Très
utile pour des problèmes comme « plus petite
capacité satisfaisant un critère », « plus
grande valeur respectant une contrainte », etc.

]]> 1.0 0.0 0 true true abc Compter les True puis renvoyer leur position

]]> Erreur : compter les True (ou les False)
demande de parcourir toute la liste, donc
O(n). On perd l'avantage logarithmique.

]]> Une recherche linéaire suffit, on ne peut pas faire mieux

]]> Erreur : on peut faire mieux. La liste est
triée (tous les False avant tous les
True), ce qui permet la dichotomie.

]]> Trier la liste de booléens à nouveau

]]> Erreur : la liste est déjà triée par
hypothèse. Trier une liste déjà triée ne
change rien, et coûte O(n log n).

]]> Une dichotomie adaptée : on regarde le
milieu, si c'est True la frontière est à
gauche ou ici, sinon elle est strictement à
droite ; on rétrécit l'intervalle jusqu'à
isoler la frontière

]]> Bonne réponse : la dichotomie ne se limite
pas à la recherche d'égalité. Dès qu'une
propriété est monotone (vraie partout
au-dessus d'un seuil, fausse en-dessous),
on peut chercher le seuil par dichotomie
en O(log n), en adaptant légèrement le
code (test sur la propriété au lieu d'une
égalité, et choix de la moitié à
conserver selon la réponse).

]]>