$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 dans un ordre défini (par exemple croissant)

]]> 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, on utilise un set ou une étape
séparée.

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

]]> Erreur : aucun changement de type.

]]> La couper en plusieurs morceaux

]]> 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 plus petit élément non trié et le placer en début de la partie non triée

]]> 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 chaque paire d'éléments 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 nouvel élément à la bonne place dans la partie déjà triée à sa gauche

]]> 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 l'ordre des éléments

]]> 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 : ce serait possible avec des tris
avancés (tri fusion en n log n, 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 de doublons identiques

]]> Cas favorable mais pas optimal : chaque
insertion fait au moins une comparaison.

]]> 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 avec doublons

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

]]> Liste vide

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

]]> Tris par sélection et par insertion — Q10 : Stabilité d'un tri Un tri est dit stable si :

]]> La stabilité est essentielle quand on trie sur
une clé secondaire après une clé principale
(par exemple, trier des élèves par âge puis
par nom : il faut que le tri par âge préserve
l'ordre alphabétique).

]]> 1.0 0.0 0 true true abc Il préserve l'ordre relatif des éléments égaux

]]> Bonne réponse : si deux éléments ont la
même clé de tri, leur ordre dans la
liste triée est le même que dans la liste
d'origine. Le tri par insertion est stable ;
le tri par sélection ne l'est pas en
général.

]]> Il fonctionne en temps constant

]]> Faux et sans rapport.

]]> Il ne se trompe jamais

]]> Trop vague. La correction est exigible
pour tout tri ; la stabilité est un
critère plus précis.

]]> Il ne plante jamais

]]> Réponse triviale, sans rapport.

]]> 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 liste.sort()]]> Erreur : c'est la fonction Python intégrée
(Timsort en n log n), pas un tri par
sélection.

]]>

for x in liste:
    x = min(liste)

]]> Erreur : x est une copie de la valeur,
on ne modifie pas la liste.

]]>

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.

]]>

while liste != sorted(liste):
    pass

]]> Boucle infinie : pass ne modifie rien.

]]>

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.

]]> Aucun des deux ne tire profit de la situation, ils sont aussi lents l'un que l'autre

]]> Erreur : il y a une différence importante
en pratique. Le tri par insertion sait
tirer parti des données déjà triées, ce
qui n'est pas le cas du tri par sélection.

]]> Tri par sélection

]]> Erreur : la sélection fait toujours un coût
quadratique, même sur une liste déjà
triée. Elle ne sait pas tirer parti de
l'état des données.

]]> 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 est inchangée

]]> 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 plus petits ou égaux à tous les autres

]]> 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 a un variant strict : le for parcourt un range fini, et le while interne du tri par insertion fait décroître strictement j, minoré par $0$

]]> Bonne réponse : un for sur un range
fini termine automatiquement (variant
implicite). Pour le while du tri par
insertion, on observe que 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 tri n'a de boucle while

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

]]> Parce que les listes Python sont finies

]]> Vrai mais pas la justification suffisante :
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, aucune décale). 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 de la mémoire

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

]]> Aucun intérêt

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

]]> Parce qu'on pourra ensuite utiliser la recherche dichotomique (coût logarithmique) 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 éviter les bugs

]]> Trier ne corrige aucun bug
dans le code de recherche.
Le bénéfice du tri préalable
est purement algorithmique :
il rend la dichotomie
applicable.

]]> Tris par sélection et par insertion — Q20 : Tris natifs Python Pourquoi liste.sort() n'utilise-t-il pas
le tri par sélection ou par insertion ?

]]> Au programme de Première : sélection et
insertion (compréhension). En pratique
(Terminale et au-delà) : tris en n log n
(fusion, rapide, Timsort).

]]> 1.0 0.0 0 true true abc Parce que Python ne sait pas les implémenter

]]> Python sait parfaitement
implémenter ces tris ; on
le fait régulièrement à
des fins pédagogiques. Le
choix de Timsort est dicté
par la performance, pas
par une limitation du
langage.

]]> Parce que les listes Python ne sont pas modifiables

]]> Erreur : les listes sont modifiables.

]]> Parce qu'aucun tri n'est implémenté

]]> La méthode liste.sort()
existe et trie effectivement
la liste. Elle s'appuie sur
Timsort, un algorithme très
performant intégré au cœur
de CPython.

]]> Parce que Python utilise un tri plus efficace (Timsort, en n log n) sur les grandes listes

]]> Bonne réponse : Timsort (hybride mêlant
insertion sur petits blocs et fusion) est
beaucoup plus rapide que sélection ou
insertion. Python applique cependant le
tri par insertion sur les sous-tableaux
de moins de ~ 64 éléments.

]]> 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 La complexité est trop élevée

]]> Erreur : la complexité est correcte, c'est
la borne qui plante.

]]> La borne externe est len(liste) + 1 au lieu de len(liste) ; à la dernière itération, on accède à liste[len(liste)] qui n'existe pas → IndexError

]]> Bonne réponse : bug d'off-by-one.
Toujours vérifier les bornes des boucles.
La forme correcte est

range(1,

len(liste))

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

]]> Erreur : la syntaxe est valide.

]]> Aucun bug

]]> 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 — Q23 : Stabilité de la sélection Pourquoi le tri par sélection n'est-il en
général pas stable ?

]]> Pour avoir un tri par sélection stable, il
faudrait décaler au lieu d'échanger (plus
coûteux). En pratique, l'insertion ou un tri
stable plus efficace est préféré.

]]> 1.0 0.0 0 true true abc Parce qu'il modifie la liste en place

]]> Erreur : l'insertion aussi modifie en place
et est stable.

]]> Parce que l'échange entre liste[i] et liste[j_min] peut faire passer un élément avant un autre élément égal

]]> Bonne réponse : exemple [2a, 2b, 1]
(où 2a et 2b sont deux éléments égaux à 2
dans cet ordre). Sélection trouve min=1,
échange : [1, 2b, 2a]. L'ordre relatif
de 2a et 2b est inversé. Donc non stable.

]]> Parce qu'il est lent

]]> Erreur : performance et stabilité sont
indépendantes.

]]> Parce qu'il utilise des doubles boucles

]]> Erreur : l'insertion aussi.

]]> 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 — Q28 : Stabilité : application pratique On a une liste d'élèves représentée par des
couples (nom, classe), déjà triée par nom.
On veut maintenant la trier par classe tout
en conservant l'ordre alphabétique des noms à
l'intérieur de chaque classe. Pourquoi
faut-il un tri stable ?

]]> Schéma général du tri multi-critères : trier
d'abord par critère secondaire, puis par
critère principal avec un tri stable. C'est
pour cela que la fonction sorted() de Python,
qui utilise Timsort, est garantie stable.

]]> 1.0 0.0 0 true true abc Parce qu'un tri stable est plus rapide qu'un tri non stable

]]> Erreur : la rapidité et la stabilité sont des
critères indépendants. Le tri par insertion
est stable et lent ; il existe des tris
rapides non stables (tri par sélection
standard, tri rapide).

]]> Parce qu'un tri stable consomme moins de mémoire

]]> Erreur : la consommation mémoire dépend de
l'algorithme (en place ou non), pas de la
stabilité. Le tri par sélection est en
place mais n'est pas stable.

]]> Parce que les classes sont des chaînes de caractères

]]> Erreur : la stabilité n'a rien à voir avec
le type des clés. Elle concerne le
traitement des éléments dont les clés sont
égales, quel que soit le type.

]]> Parce qu'un tri stable préserve l'ordre
relatif des élèves ayant la même classe ;
ainsi, à l'intérieur de chaque classe,
l'ordre alphabétique des noms (issu du
premier tri) est conservé

]]> Bonne réponse : c'est l'application typique
de la stabilité, le tri multi-critères. On
trie d'abord sur le critère secondaire
(nom), puis sur le critère principal
(classe) avec un tri stable. À l'arrivée,
les élèves sont rangés par classe puis par
nom.

]]> 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]. La passe $4$
(sur le dernier élément seul) ne
change rien

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

]]> 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$ (insertion du $1$) :
[1, 3, 4, 2]. Après $i = 2$
(insertion du $4$) : [1, 3, 4, 2]
(inchangée, $4$ est déjà à sa place).
Après $i = 3$ (insertion du $2$) :
[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 Comment adapter un tri par insertion
croissant pour qu'il trie en ordre
décroissant ?

]]> 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 ou list.sort :
sorted(liste, key=lambda x: -x.age) ou
reverse=True pour l'ordre 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
la question demandait comment
adapter le tri lui-même. 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 dans
la boucle interne : utiliser
liste[j - 1] < liste[j] au lieu de
liste[j - 1] > liste[j]

]]> Bonne réponse : la comparaison entre
deux éléments adjacents décide si on
les permute. En inversant le sens, 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 fonctionne normalement et
renvoie [1, 2, 3, 3, 3]. Si le tri
est stable, l'ordre relatif des
trois 3 (qui étaient en positions
$0$, $2$, $4$ d'origine) est préservé

]]> 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. Pour
des entiers, cette distinction est
invisible (un $3$ vaut un $3$). Mais
pour des objets avec des clés
composites (par exemple
(nom, age) triés par age), la
stabilité préserve l'ordre alphabétique
interne.

]]> Les doublons sont automatiquement
supprimés

]]> 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 convertir en set puis
retrier).

]]> L'algorithme tombe en boucle infinie

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

]]> Le tri lève une exception

]]> Erreur : aucun problème logique avec
les doublons. Les algorithmes de tri
sont conçus pour fonctionner avec
n'importe quelle suite de valeurs
comparables, doublons compris.

]]>