$course$/QCM de NSI/Première/Tris par sélection et par insertion Algorithmes de tri étudiés en Première NSI conformément
au programme officiel : tri par sélection et tri par
insertion. Principes, implémentations Python, invariants
de boucle, terminaison, coût quadratique au pire,
stabilité, comparaison.

]]> Tris par sélection et par insertion — Q01 : Qu'est-ce qu'un tri ? Que signifie « trier une liste » en informatique ?

]]> Trier permet ensuite des opérations efficaces
(recherche dichotomique, médiane, fusion).
Au programme de Première : tri par sélection
et tri par insertion.

]]> 1.0 0.0 0 true true abc Réorganiser ses éléments selon un ordre défini

]]> Bonne réponse : un tri produit une
permutation de la liste d'origine
respectant un ordre (croissant, décroissant,
alphabétique, etc.).

]]> Supprimer les doublons

]]> Erreur : trier ne supprime pas les doublons.
Pour cela, il faut une étape séparée, par
exemple un parcours qui ne recopie dans une
nouvelle liste que les valeurs pas encore
vues.

]]> Convertir les éléments en chaînes

]]> Erreur : aucun changement de type.

]]> La découper en plusieurs morceaux de tailles égales

]]> Erreur : c'est le découpage, pas le tri.

]]> Tris par sélection et par insertion — Q02 : Tri par sélection : principe Quel est le principe du tri par sélection ?

]]> Sélection : « je cherche le min du non trié, je
le mets en tête de la partie non triée, je
recommence sur le reste ». Simple et systématique.

]]> 1.0 0.0 0 true true abc Couper la liste en deux et trier chaque moitié

]]> Erreur : couper la liste en deux n'est pas sélectionner un
minimum. Le tri par sélection ne découpe rien : il cherche le plus
petit élément de la partie non triée.

]]> Insérer chaque élément à sa place dans la partie déjà triée

]]> Erreur : c'est le tri par insertion.

]]> Sélectionner le minimum non trié et le placer en tête du reste

]]> Bonne réponse : à chaque étape, on cherche
le minimum du sous-tableau non trié et on
l'échange avec le premier élément de cette
partie.

]]> Comparer systématiquement chaque paire d'éléments voisins adjacents

]]> Erreur : comparer des voisins deux à deux n'est pas chercher le
minimum de tout le reste de la liste.

]]> Tris par sélection et par insertion — Q03 : Tri par insertion : principe Quel est le principe du tri par insertion ?

]]> C'est exactement comme on trie une main de
cartes : on prend une carte, on l'insère à sa
place dans le paquet déjà trié.

]]> 1.0 0.0 0 true true abc Insérer chaque élément à sa place dans la partie déjà triée

]]> Bonne réponse : on parcourt la liste de
gauche à droite ; pour chaque élément, on
le décale vers la gauche tant qu'il est plus
petit que son voisin de gauche.

]]> Compter le nombre d'occurrences

]]> Erreur : compter les occurrences d'une valeur ne réordonne pas la
liste. Le tri par insertion place chaque élément à sa place dans
la partie déjà triée.

]]> Sélectionner le minimum et le placer en tête

]]> Erreur : c'est le tri par sélection.

]]> Inverser complètement l'ordre de tous les éléments de la liste

]]> Erreur : aucune relation avec un tri.

]]> Tris par sélection et par insertion — Q04 : Échange Python Quelle est la façon la plus simple d'échanger deux éléments d'une liste en Python ?

]]> L'affectation simultanée est utilisée dans les
tris classiques. Compacte et lisible.

]]> 1.0 0.0 0 true true abc tmp = liste[i]; liste[i] = liste[j]; liste[j] = tmp

]]> Code correct mais verbeux. Python offre
plus simple.

]]> liste.swap(i, j)

]]> Erreur : la méthode .swap n'existe pas
sur les listes Python.

]]> liste[i] = liste[j]

]]> Erreur : on perd la valeur originale en
liste[i].

]]> liste[i], liste[j] = liste[j], liste[i]

]]> Bonne réponse : affectation simultanée,
syntaxe pythonique. Python crée un tuple
temporaire (liste[j], liste[i]) puis
déballe.

]]> Tris par sélection et par insertion — Q05 : Coût au pire cas Quel est le coût au pire cas du tri par
sélection et du tri par insertion sur une liste
de longueur n ?

]]> Le coût quadratique vient de la double boucle : pour chacun des n
éléments, on parcourt une partie de la liste. Doubler la taille de
la liste multiplie donc le temps de calcul par quatre environ.

]]> 1.0 0.0 0 true true abc Logarithmique

]]> Erreur : aucun tri ne peut être logarithmique, il faut au moins
examiner les n éléments une fois.

]]> Constant (indépendant de n)

]]> Erreur : aucun algorithme ne trie en temps
constant.

]]> Quadratique (proportionnel à n²)

]]> Bonne réponse : les deux tris sont
quadratiques au pire à cause d'une
double boucle sur la liste. Pour
n = 1000, on fait ~ 10⁶ opérations.

]]> Linéaire (proportionnel à n)

]]> Erreur : trop optimiste. La double boucle
impose plus.

]]> Tris par sélection et par insertion — Q06 : Tri en place Que signifie « tri en place » ?

]]> Un tri non en place crée une copie triée
(par exemple sorted(liste) en Python). Avec
liste.sort(), on trie en place.

]]> 1.0 0.0 0 true true abc Le tri se fait sur place dans le disque dur

]]> Erreur : aucune relation avec le stockage
physique.

]]> Le tri remplace les valeurs par leurs indices

]]> Erreur : le tri ne modifie que l'ordre, pas
les valeurs.

]]> Le tri ne fonctionne que sur des listes courtes

]]> Erreur : aucune restriction de taille.

]]> Le tri ne crée pas de nouvelle liste : il modifie la liste d'origine

]]> Bonne réponse : un tri en place utilise une
quantité de mémoire constante
(indépendante de n), juste quelques
variables temporaires. Sélection et
insertion sont des tris en place.

]]> Tris par sélection et par insertion — Q07 : Tri par insertion : meilleur cas Quel est le meilleur cas pour le tri par insertion ?

]]> Cette propriété fait du tri par insertion un
bon choix pour les listes presque triées
(par exemple un fichier journal triable au fil
de l'eau).

]]> 1.0 0.0 0 true true abc Liste déjà triée

]]> Bonne réponse : si la liste est déjà triée,
chaque élément est déjà à sa place ; on ne
fait que vérifier (un seul test par
élément). Coût linéaire (n - 1
comparaisons).

]]> Liste de longueur impaire

]]> Erreur : la parité de la longueur n'a
aucune influence.

]]> Liste mélangée aléatoirement

]]> Erreur : c'est le cas moyen, de coût
quadratique (chaque élément remonte en
moyenne la moitié de la partie triée).

]]> Liste triée à l'envers

]]> Erreur : c'est au contraire le pire cas
pour insertion (chaque élément remonte tout
à fait à gauche).

]]> Tris par sélection et par insertion — Q08 : Trace tri par sélection On trie [4, 1, 3] par tri par sélection
(croissant). Que vaut la liste après la
première passe ?

]]> Tri sélection passe par passe : passe 1 fixe
l'élément en position 0 ; passe 2 fixe celui en
position 1 ; etc.

]]> 1.0 0.0 0 true true abc [1, 3, 4]

]]> Erreur : c'est le résultat final, pas
après une passe.

]]> [1, 4, 3]

]]> Bonne réponse : on cherche le min de la
liste entière (= 1, indice 1), on l'échange
avec liste[0]. Résultat : [1, 4, 3].

]]> [3, 1, 4]

]]> Erreur : aucune permutation cohérente avec
la sélection.

]]> [4, 1, 3]

]]> Erreur : la liste a bien été modifiée à la
première passe.

]]> Tris par sélection et par insertion — Q09 : Tri par insertion : pire cas Quel est le pire cas pour le tri par
insertion ?

]]> Symétrie typique : « ordre inverse » est
souvent le pire cas pour les tris naïfs ;
« déjà trié » est souvent le meilleur cas pour
l'insertion.

]]> 1.0 0.0 0 true true abc Liste triée à l'envers (décroissant)

]]> Bonne réponse : chaque nouvel élément doit
être déplacé jusqu'au début de la partie
déjà traitée, soit n(n-1)/2 décalages au
total. Coût quadratique.

]]> Liste déjà triée

]]> Erreur : c'est le meilleur cas (linéaire).

]]> Liste comportant de nombreuses valeurs en double

]]> Pas spécifique : le coût dépend de l'ordre,
pas des doublons.

]]> Liste entièrement vide, sans aucun élément à traiter

]]> Pas un pire cas : coût constant (la boucle
ne s'exécute pas).

]]> Tris par sélection et par insertion — Q11 : Code tri par sélection Quel code implémente correctement le tri par sélection croissant ?

]]> Schéma classique : j_min mémorise l'indice
du minimum, échange à la fin pour minimiser
les écritures.

]]> 1.0 0.0 0 true true abc

for i in range(len(liste)):
    j_min = i
    for j in range(i + 1, len(liste) - 1):
        if liste[j] < liste[j_min]:
            j_min = j
    liste[i], liste[j_min] = liste[j_min], liste[i]

]]> Erreur : len(liste) - 1 exclut le dernier
élément de la recherche du minimum. S'il est
le plus petit, il n'est jamais déplacé :
[2, 3, 1] reste [2, 3, 1].

]]>

for i in range(len(liste)):
    j_min = i
    for j in range(i + 1, len(liste)):
        if liste[j] > liste[j_min]:
            j_min = j
    liste[i], liste[j_min] = liste[j_min], liste[i]

]]> Erreur : la comparaison est inversée
(> au lieu de <) : la boucle interne
cherche le maximum, ce code trie donc
en ordre décroissant.

]]>

for i in range(len(liste)):
    j_min = i
    for j in range(i + 1, len(liste)):
        if liste[j] < liste[j_min]:
            j_min = j
    liste[i], liste[j_min] = liste[j_min], liste[i]

]]> Bonne réponse : double boucle ; la boucle
interne cherche l'indice du min ; échange
avec liste[i] à la fin.

]]>

for i in range(len(liste) - 1):
    if liste[i] > liste[i + 1]:
        liste[i], liste[i + 1] = liste[i + 1], liste[i]

]]> Erreur : une seule passe, ne trie pas
complètement.

]]> Tris par sélection et par insertion — Q12 : Code tri par insertion Quel code implémente correctement le tri par insertion croissant ?

]]> Variante équivalente : sauvegarder
valeur = liste[i], décaler à droite les
éléments plus grands, insérer la valeur. Plus
économe en échanges.

]]> 1.0 0.0 0 true true abc

for i in range(len(liste)):
    liste.append(min(liste))

]]> Erreur : on ajoute des éléments au lieu de
réorganiser.

]]>

for i in range(1, len(liste)):
    j = i
    while j > 0 and liste[j - 1] > liste[j]:
        liste[j - 1], liste[j] = liste[j], liste[j - 1]
        j -= 1

]]> Bonne réponse : pour chaque élément à
partir du second, on le décale vers la
gauche tant qu'il est plus petit que son
voisin gauche.

]]>

for i in range(1, len(liste)):
    j = i
    while j > 0 and liste[j - 1] > liste[j]:
        liste[j - 1], liste[j] = liste[j], liste[j - 1]

]]> Erreur : il manque le j -= 1 dans le
while : l'élément n'est remonté que
d'une seule position, et le tri échoue
dès qu'un élément doit remonter de plus
d'une case (tester sur [3, 4, 1]).

]]>

for i in range(len(liste)):
    for j in range(i):
        if liste[i] < liste[j]:
            liste[i] = liste[j]

]]> Erreur : liste[i] = liste[j] écrase la
valeur sans la sauvegarder. La liste est
corrompue.

]]> Tris par sélection et par insertion — Q13 : Liste presque triée Entre le tri par insertion et le tri par sélection, lequel est le plus rapide sur une
liste « presque triée » (peu d'éléments mal
placés) ?

]]> Cette propriété explique qu'on préfère le tri par insertion sur les
petites listes ou sur les listes presque triées.

]]> 1.0 0.0 0 true true abc Les deux sont équivalents

]]> Erreur : leur comportement diffère
précisément dans le cas favorable.
L'insertion s'adapte aux données déjà
triées, la sélection non.

]]> Le tri par sélection, car il effectue moins d'échanges

]]> Erreur : la sélection fait certes peu
d'échanges, mais son nombre de
comparaisons reste quadratique quel
que soit l'état de la liste. Sur une
liste presque triée, l'insertion (coût
quasi linéaire) l'emporte largement.

]]> Impossible à prévoir sans connaître les valeurs

]]> Erreur : pas besoin des valeurs, on
raisonne sur les algorithmes : l'insertion
s'arrête dès que l'élément est à sa place,
la sélection balaie toujours tout le reste
de la liste.

]]> Tri par insertion

]]> Bonne réponse : sur une liste presque
triée, le tri par insertion est en coût
linéaire (peu de décalages). C'est pour
cela qu'on le préfère sur les petites
listes ou les listes presque triées.

]]> Tris par sélection et par insertion — Q14 : Invariant tri par sélection Quel invariant vérifie le tri par sélection
après l'itération i de la boucle externe ?

]]> Cet invariant rend la correction du tri par
sélection évidente. Il combine deux conditions :
« triés » + « plus petits que les autres ».

]]> 1.0 0.0 0 true true abc La liste reste totalement inchangée par rapport au départ

]]> Erreur : on a fait des échanges.

]]> Les i premiers éléments sont les plus grands

]]> Erreur : c'est l'inverse pour un tri
croissant.

]]> Les i premiers éléments sont triés et inférieurs aux suivants

]]> Bonne réponse : c'est l'invariant clé. À la
fin (i = n), les n premiers (= toute la
liste) sont triés.

]]> La liste est entièrement triée

]]> Trop fort : seules les i premières
positions sont triées.

]]> Tris par sélection et par insertion — Q15 : Terminaison Pourquoi les tris par sélection et par
insertion terminent toujours ?

]]> Justification rigoureuse : pour chaque boucle,
identifier ce qui change strictement à chaque
itération (variant) et la borne qui sera
atteinte.

]]> 1.0 0.0 0 true true abc Parce que chaque boucle possède un variant qui décroît strictement

]]> Bonne réponse : un for sur un range
fini termine automatiquement (variant
implicite). Pour le while du tri par
insertion, j décroît strictement à
chaque tour et reste minoré par $0$, donc
la boucle s'arrête en au plus j
itérations.

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

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

]]> Parce qu'aucun de ces deux tris n'utilise de boucle while non bornée

]]> Erreur : le tri par insertion utilise un
while.

]]> Parce que les listes Python sont toujours de taille finie

]]> Vrai mais pas une justification suffisante :
une boucle while peut tourner sans fin sur
une liste finie ; il faut prouver que les
boucles s'arrêtent.

]]> Tris par sélection et par insertion — Q16 : Trace tri par insertion On trie [3, 1, 4, 1, 5] par tri par
insertion croissant. Quel est l'état de la
liste après l'itération i = 3 ?

]]> Méthode : à chaque itération i, l'élément
liste[i] rejoint à sa bonne place la partie
déjà triée, formée des éléments d'indices
$0$ à $i - 1$.

]]> 1.0 0.0 0 true true abc [3, 1, 4, 1, 5]

]]> Erreur : c'est la liste d'origine non
modifiée.

]]> [1, 1, 3, 4, 5]

]]> Bonne réponse. Trace : i=1 → [1, 3, 4, 1, 5] ;
i=2 → [1, 3, 4, 1, 5] (le 4 ne bouge pas) ;
i=3 → on insère le 1 (indice 3) à sa place
: [1, 1, 3, 4, 5].

]]> [1, 3, 4, 1, 5]

]]> Erreur : c'est l'état après i = 2
(l'élément d'indice 2 a rejoint sa
place dans la partie triée).

]]> [1, 3, 1, 4, 5]

]]> Erreur : le 1 doit aller jusqu'à l'indice
1, pas à l'indice 2.

]]> Tris par sélection et par insertion — Q17 : Nombre d'échanges sélection Combien d'échanges (au maximum) effectue le
tri par sélection sur une liste de longueur n ?

]]> Caractéristique remarquable du tri par
sélection : très peu d'échanges, indépendamment
de l'ordre initial. Avantageux quand les
écritures sont coûteuses (mémoire flash).

]]> 1.0 0.0 0 true true abc log n

]]> Erreur : pas de mécanisme dichotomique.

]]> n - 1

]]> Bonne réponse : un échange par itération
de la boucle externe. Quel que soit l'ordre
initial, on fait au plus n - 1 échanges
(parfois on évite l'échange si j_min = i,
mais pour le pire cas, c'est n - 1).

]]> n × (n - 1) / 2

]]> Erreur : c'est l'ordre de grandeur des
comparaisons, pas des échanges.

]]> n

]]> Erreur : la dernière itération est inutile.

]]> Tris par sélection et par insertion — Q18 : Sélection vs insertion Sur une liste déjà triée de 1000 éléments,
quel tri est le plus rapide ?

]]> Choix selon le cas pratique : sélection si
les écritures sont coûteuses (peu d'échanges),
insertion si les données arrivent presque
triées.

]]> 1.0 0.0 0 true true abc Aucun ne fonctionne

]]> Les deux algorithmes sont
parfaitement corrects ; ils
finiront par trier la liste.
La question portait sur leur
performance comparée, et le
tri par insertion est très
rapide sur une liste presque
triée.

]]> Le tri par sélection

]]> Erreur : il fait quand même le coût
quadratique (comparaisons), même si peu
d'échanges.

]]> Les deux sont équivalents

]]> Erreur : différence d'ordre de grandeur sur
ce cas.

]]> Le tri par insertion

]]> Bonne réponse : sur une liste déjà triée,
l'insertion est en coût linéaire (~ n
comparaisons, aucun décalage). La sélection
reste quadratique.

]]> Tris par sélection et par insertion — Q19 : Trier puis chercher On veut faire plusieurs recherches
d'éléments dans une liste. Pourquoi peut-il
être intéressant de la trier d'abord ?

]]> Investissement initial (tri) vs économie sur
les recherches futures. Pour une seule
recherche, le tri n'est pas rentable.

]]> 1.0 0.0 0 true true abc Pour économiser une quantité importante de mémoire vive

]]> Erreur : trier ne change pas la mémoire.

]]> Aucun, le tri coûte plus cher que toutes les recherches

]]> Au contraire, dès que l'on
fait plusieurs recherches,
trier une fois pour toutes
devient très rentable, car
chaque recherche passe d'un
coût linéaire à un coût
logarithmique.

]]> Pour utiliser ensuite la recherche dichotomique plutôt que linéaire

]]> Bonne réponse : le tri, quadratique avec la sélection ou
l'insertion, est un investissement amorti par de nombreuses
recherches dichotomiques rapides.

]]> Pour rendre chaque recherche linéaire deux fois plus rapide

]]> Erreur : trier ne change pas le coût d'une
recherche linéaire, qui reste
proportionnel à la taille. Le bénéfice du
tri préalable est de rendre la
dichotomie applicable.

]]> Tris par sélection et par insertion — Q21 : Bug d'indice

for i in range(1, len(liste) + 1):
    j = i
    while j > 0 and liste[j - 1] > liste[j]:
        liste[j - 1], liste[j] = liste[j], liste[j - 1]
        j -= 1

Pourquoi ce code (tentative de tri par
insertion) est-il bogué ?

]]> Les erreurs de borne d'une unité sont très fréquentes. Il faut
toujours tester avec des listes simples ([], [1], [1, 2])
pour les détecter.

]]> 1.0 0.0 0 true true abc Sa complexité est trop élevée pour un tri par insertion

]]> Erreur : la complexité (quadratique) est
celle attendue pour un tri par insertion ;
le problème est ailleurs, dans une borne
de boucle.

]]> La dernière itération accède à liste[len(liste)], qui n'existe pas

]]> Bonne réponse : c'est une erreur de borne d'une unité. La borne
externe est len(liste) + 1 au lieu de len(liste) : au dernier
tour, i = len(liste) puis j = i, et l'accès liste[j] lève une
IndexError. La forme correcte est range(1, len(liste)).

]]> La fonction range n'accepte pas deux paramètres

]]> Erreur : la syntaxe range(début, fin) est
parfaitement valide.

]]> Il n'y a aucun bug, ce code trie correctement la liste

]]> Le code contient bien une
erreur de borne : la boucle
va jusqu'à len(liste)
inclus, ce qui provoque un
accès hors tableau lors de
la dernière itération.

]]> Tris par sélection et par insertion — Q22 : Nombre de comparaisons Combien de comparaisons effectue le tri par
sélection sur une liste de longueur n,
quel que soit l'ordre initial ?

]]> Différence majeure : insertion s'adapte (cas
favorable linéaire), sélection ne s'adapte
pas. Pour de petites listes presque triées,
préférer l'insertion.

]]> 1.0 0.0 0 true true abc Environ n²/2 comparaisons (toujours)

]]> Bonne réponse : la boucle externe fait n
itérations, l'interne fait en moyenne n/2.
Total : n × n/2 = n²/2 comparaisons. Le tri par sélection ne tire aucun parti
d'un ordre favorable : il fait toujours le
même travail.

]]> Environ log n

]]> Erreur : pas de dichotomie.

]]> Environ n comparaisons

]]> Erreur : la double boucle impose
quadratique.

]]> Aucune si la liste est déjà triée

]]> Erreur : la sélection ne « voit » pas que la
liste est triée. Elle parcourt quand même
tout.

]]> Tris par sélection et par insertion — Q24 : Choisir un tri Pour trier une liste de 5 éléments dans un
microcontrôleur où l'on doit minimiser l'écriture en mémoire flash (les écritures
sont lentes), quel tri choisir parmi
sélection et insertion ?

]]> Le choix d'un algorithme dépend du contexte matériel et des contraintes (mémoire,
énergie, écritures, temps). Pas d'algorithme
universel.

]]> 1.0 0.0 0 true true abc Les deux, qui font autant d'échanges au pire

]]> Erreur : au pire, le tri par sélection fait $n - 1 = 4$ échanges
alors que le tri par insertion peut en faire
$\frac{n(n-1)}{2} = 10$. Ils ne se valent pas sur ce critère.

]]> Tri par insertion

]]> Erreur : peut faire jusqu'à n(n-1)/2 = 10
échanges au pire.

]]> Tri par sélection

]]> Bonne réponse : il fait au plus n - 1 = 4
échanges, indépendamment de l'ordre
initial. Optimal pour minimiser les
écritures.

]]> Aucun des deux, car chacun réécrit toute la liste à chaque passe

]]> Erreur : aucun des deux ne réécrit toute la liste à chaque passe.
La sélection fait un seul échange par passe, ce qui limite les
écritures à $n - 1 = 4$ échanges.

]]> Tris par sélection et par insertion — Q25 : Synthèse Parmi les affirmations suivantes sur les tris
au programme (sélection, insertion), laquelle
est fausse ?

]]> À retenir : la sélection fait peu d'échanges (au plus $n - 1$) mais
toujours autant de comparaisons, quel que soit l'ordre initial.
L'insertion s'adapte au cas favorable (coût linéaire sur une liste
triée) mais peut faire beaucoup d'échanges au pire.

]]> 1.0 0.0 0 true true abc Le coût au pire des deux est quadratique.

]]> Vrai : caractéristique commune.

]]> Les deux tris peuvent être implémentés en place (sans liste auxiliaire).

]]> Vrai : caractéristique commune.

]]> Le tri par sélection est en coût linéaire sur une liste déjà triée.

]]> Faux (donc bonne réponse) : même sur une liste déjà triée, le tri
par sélection parcourt toute la partie non triée à chaque passe
pour chercher le minimum. Il fait toujours $\frac{n(n-1)}{2}$
comparaisons, son coût reste quadratique.

]]> Le tri par insertion est en coût linéaire sur une liste déjà triée.

]]> Vrai : sa propriété remarquable
(meilleur cas).

]]> Tris par sélection et par insertion — Q26 : Tri par insertion par décalage Une variante classique du tri par insertion ne
fait pas d'échanges deux à deux mais un
décalage suivi d'une insertion. Quel code
met cette idée en œuvre correctement ?

]]> Cette variante est en général plus rapide en pratique : un décalage
demande une seule écriture, contre deux pour un échange.

]]> 1.0 0.0 0 true true abc

for i in range(1, len(liste)):
    valeur = liste[i]
    j = i
    while j > 0 and liste[j - 1] > valeur:
        liste[j] = liste[j - 1]
        j -= 1

]]> Erreur : il manque la dernière étape
liste[j] = valeur. La valeur sauvegardée
n'est jamais réinsérée, et la position
libérée garde sa valeur précédente déjà
décalée. La liste est corrompue.

]]>

for i in range(1, len(liste)):
    valeur = liste[i]
    for j in range(i, 0, -1):
        liste[j] = valeur

]]> Erreur : on remplit toutes les positions de
j = i jusqu'à j = 1 avec la même
valeur. La liste finit par contenir des
copies multiples du même élément.

]]>

for i in range(1, len(liste)):
    valeur = liste[i]
    j = i
    while j > 0 and liste[j - 1] > valeur:
        liste[j] = liste[j - 1]
        j -= 1
    liste[j] = valeur

]]> Bonne réponse : on sauvegarde la valeur
courante, on décale vers la droite tous les
éléments plus grands à gauche, puis on
insère la valeur à la position libérée. Une
seule écriture par décalage (au lieu de deux
dans la version par échanges), donc plus
rapide en pratique.

]]>

for i in range(1, len(liste)):
    j = i
    while j > 0 and liste[j - 1] > liste[j]:
        liste[j] = liste[j - 1]
        j -= 1

]]> Erreur : on n'a pas sauvegardé la valeur
d'origine de liste[i] avant de la
remplacer par liste[j - 1]. Dès la
première itération, cette valeur est
perdue, donc l'insertion finale est
impossible.

]]> Tris par sélection et par insertion — Q27 : Comparaisons précises sur exemple Combien de comparaisons (entre éléments)
effectue le tri par sélection sur la liste
[5, 3, 8, 1] (n = 4) ?

]]> Formule à retenir : n(n - 1) / 2
comparaisons pour le tri par sélection, quel que soit l'ordre initial. C'est l'ordre de
grandeur quadratique. Pour n = 1000 :
499 500 comparaisons.

]]> 1.0 0.0 0 true true abc 4

]]> Erreur : c'est le nombre d'éléments. La
double boucle fait beaucoup plus de
comparaisons.

]]> 16

]]> Erreur : ce serait n², mais le tri par
sélection fait n(n - 1) / 2
comparaisons, pas n². La boucle interne
ne repart pas de zéro à chaque passe.

]]> 3

]]> Erreur : ce serait le nombre d'itérations
de la boucle externe (n - 1), pas le total
des comparaisons internes.

]]> 6

]]> Bonne réponse : la formule générale est
(n - 1) + (n - 2) + ... + 1 = n(n - 1) / 2,
soit ici 4 × 3 / 2 = 6. Détail : passe 1 → 3 comparaisons ; passe 2 → 2 comparaisons ; passe 3 → 1 comparaison. Total : 6.

]]> Tris par sélection et par insertion — Q29 : Trace pas-à-pas du tri par sélection On trie la liste [3, 1, 4, 2] par tri par
sélection croissant. Quels sont les états
successifs de la liste après chaque itération de la boucle externe (chaque
« passe ») ?

]]> Pour tracer le tri par sélection, on tient
à jour à chaque passe : (1) la position
courante pos, (2) l'indice du minimum parmi
les éléments d'indices pos à n - 1, (3)
l'échange éventuel. La liste se trie de gauche
à droite, un élément à la fois. Pour n = 4
éléments, $3$ passes suffisent : une quatrième
passe, sur un seul élément, serait inutile.

]]> 1.0 0.0 0 true true abc Après passe $1$ : [1, 3, 4, 2]. Après
passe $2$ : [1, 2, 4, 3]. Après passe
$3$ : [1, 2, 3, 4]

]]> Bonne réponse : à chaque passe, on
cherche le minimum à partir de la
position courante et on l'échange avec
l'élément en cette position. Passe $1$
(position $0$) : minimum de
[3, 1, 4, 2] est $1$ en position
$1$, on échange → [1, 3, 4, 2].
Passe $2$ (position $1$) : minimum de
[3, 4, 2] est $2$ en position $3$,
on échange liste[1] avec liste[3]
→ [1, 2, 4, 3]. Passe $3$ (position
$2$) : minimum de [4, 3] est $3$,
on échange → [1, 2, 3, 4]. Une éventuelle
passe $4$, sur le dernier élément seul, ne
change rien.

]]> Après passe $1$ : [3, 1, 4, 2]
(inchangée). Après passe $2$ :
[1, 3, 4, 2]. Après passe $3$ :
[1, 2, 4, 3]

]]> Erreur : la première passe modifie
bien la liste en plaçant le minimum
$1$ en position $0$. Une passe ne
laisse la liste inchangée que si
l'élément en position courante est
déjà le minimum du sous-tableau, ce
qui n'est pas le cas ici (la position
$0$ contient $3$, pas $1$).

]]> Après passe $1$ : [1, 3, 4, 2]. Après
passe $2$ : [1, 3, 2, 4]. Après passe
$3$ : [1, 2, 3, 4]

]]> Erreur à la passe $2$ : à partir de la
position $1$, on cherche le minimum
parmi [3, 4, 2], qui est $2$ en
position $3$. On échange donc
liste[1] (qui vaut $3$) avec
liste[3] (qui vaut $2$), ce qui
donne [1, 2, 4, 3] et non
[1, 3, 2, 4].

]]> Après passe $1$ : [1, 2, 3, 4]. Les
passes suivantes ne changent rien

]]> Erreur : le tri par sélection ne place
qu'un seul élément à sa position
finale par passe (le minimum du
sous-tableau restant). Il faut donc
plusieurs passes successives, et la
liste n'est triée qu'à la fin.

]]> Tris par sélection et par insertion — Q30 : Trace pas-à-pas du tri par insertion On trie la même liste [3, 1, 4, 2] par
tri par insertion croissant. Quels sont
les états successifs après chaque itération de la boucle externe ?

]]> Différence remarquable avec le tri par
sélection : une itération du tri par
insertion peut ne presque rien faire quand
l'élément est déjà bien placé.
C'est typique : si la liste est presque
triée, l'insertion devient quasi linéaire,
tandis que la sélection fait toujours le
même travail quadratique. Cette propriété
d'adaptabilité rend l'insertion
préférable sur des données quasi-triées.

]]> 1.0 0.0 0 true true abc Après $i = 1$ : [1, 3, 4, 2]. Après
$i = 2$ : [1, 3, 4, 2] (inchangée).
Après $i = 3$ : [1, 2, 3, 4]

]]> Bonne réponse : à chaque itération $i$,
on prend liste[i] et on l'insère à sa
place dans la portion déjà triée, formée
des éléments d'indices $0$ à $i - 1$.
Pour $i = 1$, le $1$ se place avant le $3$.
Pour $i = 2$, le 4 est déjà à sa place (rien à faire).
Pour $i = 3$, le 2 remonte jusqu'à se placer entre 1 et 3, ce qui décale aussi le 3 et le 4 d'un cran.

]]> Après $i = 1$ : [3, 1, 4, 2]
(inchangée). Après $i = 2$ :
[1, 3, 4, 2]. Après $i = 3$ :
[1, 3, 4, 2]

]]> Erreur : la première itération
($i = 1$) insère le $1$ à sa place
dans la portion [3], ce qui le
place avant le $3$. La liste devient
donc [1, 3, 4, 2] après cette
itération, pas inchangée.

]]> Après $i = 1$ : [1, 3, 4, 2]. Après
$i = 2$ : [1, 2, 3, 4]. Après
$i = 3$ : [1, 2, 3, 4]

]]> Erreur : à $i = 2$, on insère le $4$,
pas le $2$. La liste devient [1, 3, 4, 2],
pas [1, 2, 3, 4]. C'est à $i = 3$, en
insérant le $2$, qu'on obtient le
tri final.

]]> Identique au tri par sélection :
[1, 3, 4, 2] puis [1, 2, 4, 3] puis [1, 2, 3, 4]

]]> Erreur : les deux algorithmes ne
produisent pas les mêmes états
intermédiaires. Au tri par sélection,
chaque passe place le minimum du
reste ; au tri par insertion, chaque
passe insère l'élément suivant à sa
place dans la partie triée. Les
comportements intermédiaires diffèrent.

]]> Tris par sélection et par insertion — Q31 : Trier en ordre décroissant Quelle modification du code d'un tri par
insertion croissant le transforme en tri
décroissant, sans étape supplémentaire ni
restriction sur le type des éléments ?

]]> Cette logique se généralise : pour un tri avec un critère
arbitraire (par âge, par nom, par taille, etc.), on n'a qu'à
modifier la comparaison. Python permet cela via le paramètre
key= de sorted : avec une fonction clé nommée
def age(eleve): return eleve[1], sorted(eleves, key=age) trie
des couples (nom, age) par âge croissant.

]]> 1.0 0.0 0 true true abc Appliquer le tri croissant puis inverser la liste obtenue avec une boucle

]]> Cette approche fonctionne et ne coûte qu'un parcours
supplémentaire, mais ce n'est pas une modification du tri : c'est
une étape ajoutée après coup, que l'énoncé exclut. Modifier la
comparaison interne est plus simple et tout aussi efficace.

]]> Trier la liste à l'envers d'abord, puis
appliquer le tri croissant

]]> Erreur : « trier à l'envers d'abord » n'a pas de sens si on n'a pas
encore de tri, et cette démarche ajoute une étape au lieu de
modifier le tri.

]]> Multiplier toutes les valeurs par
$-1$, trier, puis multiplier à
nouveau par $-1$

]]> Cette astuce fonctionne pour des
nombres, mais pas pour des chaînes ou
des objets quelconques. Et elle est
inutilement compliquée par rapport à
l'inversion de la comparaison.

]]> Inverser le sens de la comparaison
de la boucle interne (< au lieu
de >)

]]> Bonne réponse : la comparaison entre
deux éléments adjacents décide si on
les permute. En écrivant
liste[j - 1] < liste[j] au lieu de
liste[j - 1] > liste[j], on trie
dans l'ordre opposé. C'est la
modification la plus simple et la
plus localisée. Pour le tri par
sélection, on cherche le maximum
au lieu du minimum à chaque passe.

]]> Tris par sélection et par insertion — Q32 : Comportement avec doublons Que se passe-t-il quand on trie une liste
contenant des doublons, par exemple
[3, 1, 3, 2, 3] ?

]]> Un tri ne change que l'ordre des éléments : la liste triée contient
exactement les mêmes valeurs, avec le même nombre d'exemplaires.
Supprimer les doublons est un autre traitement, qui demande un
parcours dédié.

]]> 1.0 0.0 0 true true abc Le tri renvoie [1, 2, 3, 3, 3],
tous les doublons étant conservés

]]> Bonne réponse : les algorithmes de tri fonctionnent parfaitement
avec des doublons. Ils réordonnent les éléments sans en retirer ni
en ajouter : les trois 3 se retrouvent côte à côte en fin de
liste.

]]> Les doublons sont supprimés et le
tri renvoie [1, 2, 3]

]]> Erreur : le tri ne supprime pas les
doublons. Il les conserve tous, dans
l'ordre. Pour supprimer les doublons,
il faut une étape distincte (par
exemple un parcours qui n'ajoute chaque
valeur à une nouvelle liste que si elle
n'y est pas déjà).

]]> Les comparaisons d'éléments égaux
font boucler l'algorithme sans fin

]]> Erreur : aucun risque de boucle
infinie. Les comparaisons restent
déterministes, les indices avancent
normalement.

]]> Le tri lève une exception, les
éléments égaux étant incomparables

]]> Erreur : deux valeurs égales sont
parfaitement comparables. Les
algorithmes de tri sont conçus pour
fonctionner avec n'importe quelle
suite de valeurs comparables,
doublons compris.

]]> Tris par sélection et par insertion — Q33 : Après le premier passage du tri par sélection Le tri par sélection cherche le minimum de la liste et l'échange
avec le premier élément, puis recommence sur le reste. Que devient
la liste [5, 2, 9, 1, 7] après le premier passage ?

]]> Chaque passage du tri par sélection place un élément à sa position
définitive, par un seul échange.

]]> 1.0 0.0 0 true true abc [1, 2, 9, 5, 7]

]]> Bonne réponse : le minimum est échangé avec l'élément en
position 0 ; le reste de la liste n'est pas réordonné.

]]> [1, 2, 5, 9, 7]

]]> Erreur : un seul échange a lieu par passage, le reste de la
liste garde son ordre.

]]> [2, 5, 9, 1, 7]

]]> Erreur : c'est le minimum qui est placé en tête, pas un autre
élément.

]]> [1, 2, 5, 7, 9]

]]> Erreur : la liste entièrement triée n'est obtenue qu'après tous
les passages.

]]> Tris par sélection et par insertion — Q34 : Le tri par sélection sur une liste déjà triée On applique le tri par sélection à une liste de $n$ éléments déjà
triée. Que peut-on dire du nombre de comparaisons effectuées ?

]]> Le tri par sélection a un coût indépendant des données ; le tri
par insertion, lui, profite d'une liste presque triée.

]]> 1.0 0.0 0 true true abc Le même que pour toute liste de $n$ éléments

]]> Bonne réponse : le tri par sélection cherche le minimum du reste
à chaque passage, quel que soit l'ordre initial. Il ne tire
aucun parti d'une liste déjà triée.

]]> Il tombe à $n - 1$, chaque élément étant déjà à sa place

]]> Erreur : c'est le tri par insertion qui se contente de $n - 1$
comparaisons sur une liste triée.

]]> Il est nul, aucun échange n'étant nécessaire

]]> Erreur : les échanges sont inutiles, mais les comparaisons pour
trouver chaque minimum ont bien lieu.

]]> Il double, la liste devant être vérifiée deux fois

]]> Erreur : rien n'est vérifié deux fois ; le coût est simplement
inchangé.

]]> Tris par sélection et par insertion — Q35 : La partie déjà triée Après $k$ passages du tri par sélection sur une liste, quelle partie
de la liste est garantie triée ?

]]> L'invariant du tri par sélection : à chaque instant, la partie
gauche est triée et contient les plus petits éléments.

]]> 1.0 0.0 0 true true abc Les $k$ premiers éléments, à leur position définitive

]]> Bonne réponse : chaque passage place le minimum du reste juste
après la partie triée. Les $k$ premiers éléments sont les $k$
plus petits, dans l'ordre.

]]> Les $k$ derniers éléments, les plus grands

]]> Erreur : le tri par sélection construit la partie triée par la
gauche.

]]> Toute la liste, dès le premier passage terminé

]]> Erreur : un passage ne place qu'un seul élément.

]]> Aucune partie, le tri ne s'achevant qu'au dernier passage

]]> Erreur : la partie gauche est triée et définitive dès les
premiers passages, c'est l'invariant du tri.

]]> Tris par sélection et par insertion — Q36 : Après l'insertion du troisième élément Le tri par insertion insère chaque élément, de gauche à droite, à
sa place dans la partie déjà triée qui le précède. Que devient la
liste [4, 7, 2, 9] juste après l'insertion de son troisième élément ?

]]> À chaque étape du tri par insertion, la partie gauche reste triée
et grandit d'un élément.

]]> 1.0 0.0 0 true true abc [2, 4, 7, 9]

]]> Bonne réponse : les deux premiers éléments forment la partie
triée ; le troisième y est inséré à sa place, et le dernier
élément n'a pas encore été traité.

]]> [2, 4, 7, 9, 2]

]]> Erreur : le quatrième élément n'est inséré qu'au passage
suivant.

]]> [4, 2, 7, 9]

]]> Erreur : l'élément est inséré à sa place dans la partie triée,
pas simplement échangé avec son voisin.

]]> [2, 7, 4, 9]

]]> Erreur : la partie triée doit rester triée après l'insertion.

]]> Tris par sélection et par insertion — Q37 : Le nombre de décalages d'une insertion La partie triée vaut [5, 8, 9] et l'élément à insérer vaut 6.
Le tri par insertion décale vers la droite chaque élément plus
grand que 6, puis le place. Combien de décalages sont
effectués ?

]]> Le coût d'une insertion est le nombre d'éléments plus grands que la
valeur insérée : nul si elle est la plus grande, maximal si elle
est la plus petite.

]]> 1.0 0.0 0 true true abc 2

]]> Bonne réponse : seuls les éléments strictement plus grands que
6 sont décalés d'un cran, et 6 prend la position 1.

]]> 1

]]> Erreur : 1 est la position finale de 6, pas le nombre
d'éléments déplacés.

]]> 3

]]> Erreur : 3 est le nombre d'éléments de la partie triée ;
seuls ceux qui dépassent 6 sont décalés.

]]> 4

]]> Erreur : 4 est la taille de la partie triée après
l'insertion, pas le nombre d'éléments déplacés.

]]> Tris par sélection et par insertion — Q38 : Classer une main de cartes Un joueur prend ses cartes une par une et glisse chacune à sa place
parmi celles qu'il tient déjà, rangées dans l'ordre. Quel tri
reproduit-il ?

]]> Le tri par insertion est celui que l'on pratique naturellement avec
des cartes ou des copies à classer.

]]> 1.0 0.0 0 true true abc Le tri par insertion

]]> Bonne réponse : la main déjà rangée est la partie triée, et
chaque nouvelle carte y est insérée à sa place.

]]> Le tri par sélection

]]> Erreur : le tri par sélection chercherait d'abord la plus petite
carte de toutes, puis la suivante.

]]> La recherche dichotomique

]]> Erreur : la dichotomie cherche une valeur, elle ne range pas.

]]> Aucun tri, l'ordre venant de la distribution

]]> Erreur : les cartes arrivent dans un ordre quelconque ; c'est
le joueur qui les trie.

]]> Tris par sélection et par insertion — Q39 : Trier des chaînes de caractères Que renvoie sorted(["pomme", "Banane", "cerise"]) ?

]]> Trier des chaînes suit l'ordre des codes de caractères : pour un
ordre alphabétique insensible à la casse, on trie sur les
minuscules.

]]> 1.0 0.0 0 true true abc ['Banane', 'cerise', 'pomme']

]]> Bonne réponse : les chaînes se comparent par les codes de leurs
caractères, et toutes les majuscules précèdent les minuscules.
'B' passe donc avant 'c'.

]]> ['Banane', 'pomme', 'cerise']

]]> Erreur : entre 'cerise' et 'pomme', 'c' précède 'p'.

]]> ['cerise', 'pomme', 'Banane']

]]> Erreur : la majuscule 'B' a un code plus petit que les
minuscules, elle vient en premier.

]]> ['pomme', 'Banane', 'cerise']

]]> Erreur : sorted renvoie une liste triée, pas l'ordre initial.

]]> Tris par sélection et par insertion — Q40 : Deux fois plus d'éléments à trier Un tri par insertion met $1$ s pour trier dix mille d'éléments dans le
pire cas. Combien de temps met-il, toujours dans le pire cas, pour
vingt mille d'éléments ?

]]> Pour un coût en $n^2$, multiplier $n$ par $2$ multiplie le temps par
$4$ : c'est ce qui rend ces tris inutilisables sur de très grandes
listes.

]]> 1.0 0.0 0 true true abc Environ $4$ s

]]> Bonne réponse : le coût est quadratique. Doubler la taille
multiplie le nombre de comparaisons par quatre, donc le temps
aussi.

]]> Environ $2$ s

]]> Erreur : un temps doublé correspondrait à un coût linéaire ; le
tri par insertion est quadratique.

]]> Environ $8$ s

]]> Erreur : un facteur huit correspondrait à un coût cubique.

]]> Toujours $1$ s

]]> Erreur : le temps dépend fortement de la taille de la liste.

]]>