$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 : c'est le tri fusion (diviser
pour régner), au programme de Terminale.

]]> 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 : ce serait l'idée du tri à bulles,
qui n'est pas au programme.

]]> 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 : c'est le « tri par comptage », un
algorithme différent (hors programme).

]]> 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 ?

]]> Coût quadratique = limite des tris « par
comparaisons simples ». Pour aller plus vite,
il faut des stratégies plus malines (diviser
pour régner, Terminale).

]]> 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. Les meilleurs tris par
comparaison atteignent n log n (tri
fusion, programme de Terminale).

]]> 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, 4, 1]

]]> 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é de l'insertion explique que
Python (Timsort, hors programme) bascule sur
le tri par insertion sur les petits sous-
tableaux.

]]> 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 la partie triée
liste[0..i-1] (en Python : liste[:i]) à sa
bonne place.

]]> 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, le 4, est déjà à sa
place).

]]> [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 (n log n par tri
fusion en Terminale, ou quadratique en
Première) est un investissement amorti par
de nombreuses recherches 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é ?

]]> Bugs « off-by-one » : très fréquents.
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 : bug d'off-by-one. 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 un 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 Aucun, il faut un tri à bulles

]]> Hors programme. Et sur le critère du
nombre d'écritures, le tri par sélection
est meilleur.

]]> 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, on doit utiliser Timsort

]]> Pas idéal sur micro-contrôleur : Timsort
est complexe à implémenter et n'est pas
forcément disponible.

]]> 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 : sélection = peu d'échanges (n-1)
mais pas stable, ne s'adapte pas au cas
favorable. Insertion = stable, excellent en
cas favorable, plus 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 stable par défaut.

]]> Faux (donc bonne réponse) : le tri par
sélection n'est pas stable en général.
L'échange peut modifier l'ordre relatif
d'éléments égaux. L'insertion, elle, est
stable.

]]> 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 = une seule écriture,
contre deux pour un échange. C'est ce que fait
Python en interne pour les petits sous-tableaux
dans Timsort.

]]> 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 (parcours indices 1 à 3) ;
passe 2 → 2 ; passe 3 → 1. 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 (position de la passe), (2)
l'indice du minimum dans le sous-tableau
liste[pos:], (3) l'échange éventuel.
La liste se trie de gauche à droite, un
élément à la fois. Pour n = 4 éléments,
$3$ passes suffisent (la dernière, sur un
seul élément, est 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 : à $i = 2$, le tri par
insertion ne fait quasiment rien (juste
une comparaison qui constate que $4 > 3$).
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
liste[0..i-1] (en Python : liste[:i]).
Pour $i = 1$, le $1$
remonte 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, 2, 3, 4]

]]> 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$. Le $4$ étant déjà à la
fin de la portion triée [1, 3], il
n'a pas besoin d'être déplacé. La
liste reste [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 à la passe $2$ 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 fonction de 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, et
sorted(eleves, key=age, reverse=True)
par âge décroissant.

]]> 1.0 0.0 0 true true abc Appliquer le tri croissant puis
inverser la liste finale avec
liste.reverse()

]]> Cette approche fonctionne et coûte
juste un $O(n)$ supplémentaire, mais
ce n'est pas une modification du tri :
c'est une étape ajoutée après coup.
Modifier la comparaison interne est
plus élégant 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. L'inversion d'une liste se
fait en $O(n)$, certes, mais ce n'est
pas la modification la plus simple
pour adapter un 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] ?

]]> Test concret : trier
[("Alice", 17), ("Bob", 17), ("Chloé", 15)]
par âge avec un tri stable donne
[("Chloé", 15), ("Alice", 17), ("Bob", 17)]
(Alice avant Bob, comme dans la liste
d'origine). Avec un tri non stable, on
pourrait obtenir aussi
[("Chloé", 15), ("Bob", 17), ("Alice", 17)]
(Bob avant Alice), ce qui peut être
gênant en pratique.

]]> 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
standard fonctionnent parfaitement
avec des doublons. La distinction
stable / non stable porte sur l'ordre
relatif des éléments égaux : un
tri stable préserve l'ordre d'origine
des trois 3 (positions $0$, $2$,
$4$). Pour des entiers, cette
distinction est invisible (un $3$
vaut un $3$), mais pour des objets à
clés composites (par exemple
(nom, age) triés par age), la
stabilité préserve l'ordre interne.

]]> 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.

]]>