Tri par insertion

Seconde 1ère Terminales

Enseignement
Numérique et Sciences Informatiques
Spécialité

 Histoire de l’informatique
 Représentation des données
 Traitement des données en tables
 Interaction entre l’homme et la machine sur le WEB
 Architectures matérielles et système d’exploitation
 Langages et programmation
 Algorithmique

Partie du référentiel traitée

Contenus Capacités attendues Commentaires
Écrire un algorithme de tri. Décrire un
Tris par insertion, par On montre que leur coût est
invariant de boucle qui prouve la correction
sélection quadratique dans le pire cas.
des tris par insertion, par sélection.

1. Historique
Betty Holberton (1917-2001)
Informaticienne, Betty Holberton est connue pour avoir été l’une des six programmatrices
originelles de l’ENIAC, le premier ordinateur électronique.

Lors de son premier jour de cours à l’université de Pennsylvanie, son professeur de

mathématiques lui demande si elle ne serait pas mieux à la maison à élever des enfants. Cela la
pousse à continuer ses études en mathématiques, tout en choisissant le journalisme comme
option majeure (le journalisme était l’un des seuls domaines ouverts aux femmes en 1940).

Pendant la Seconde Guerre Mondiale, elle est embauchée par la Moore School of Electrical Engineering en tant que
calculatrice. Elle est vite choisie pour être l’une des six programmatrices de l’ENIAC, avec Kay McNulty, Marlyn
Wescoff, Ruth Lichterman, Betty Jean Jennings, et Fran Bilas.

Elle y développe le premier code de construction, la première routine de tri et la première application logicielle.
Après la guerre, en 1959, elle est nommée directrice de la branche Recherche en Programmation du David Taylor
Model Basin, laboratoire de mathématiques appliquées. Elle participe également à développer l’Univac (la division
informatique de Remington Rand).

En 2001, celle qui est considérée comme la pionnière du logiciel par Donald E. Knuth meurt d’une maladie
cardiaque à l’âge de 84 ans.
« Source Wikipedia »

2. Principe du tri par insertion

C'est le tri qu’utilisent les joueurs de cartes pour ordonner leur jeu. Le principe est de classer progressivement les
cartes depuis la gauche.

La première carte est considérée comme à sa place. Pour chaque carte, en commençant par la seconde, on recherche
s’il est possible de la déplacer vers la gauche.

NSI Première 1 Tri par insertion

 1er passage

Partie non triée (ignorée)

Pas de solution à gauche

Partie triée
 2ème passage

Partie non triée (ignorée)

Pas de solution à gauche

 3ème passage Partie triée

Partie non triée (ignorée)

Résultat après l’opération

 4ème passage Partie triée

Résultat après
l’opération

 5ème passage

Résultat après l’opération

3. Algorithme du tri par insertion

Ligne Tri_insertion(Liste T)
1 n  Taille de la liste
2 Pour i de 1 à n – 1
3 Temp  T[i]
4 ji
Boucle n°1

5 Tant que j > 0 et Temp < T[j - 1]

Boucle

6 T[j]  T[j - 1]
n°2

7 jj–1
Fin tant que
8 T[j]  Temp
Fin pour

4. Complexité
 Cas favorable (la liste est déjà triée)
Ligne Nombre d’affectations Nombre de comparaisons Nombre d’opérations
1
2
3
4

NSI Première 2 Tri par insertion

 5
6
7
8
Total

Coût total (n) =

………..
A savoir …
Dans le cas le plus favorable, c'est-à-dire lorsque le tableau est déjà trié comme on le souhaite, la complexité
est linéaire soit O(n).

Il serait possible de gagner un peu de temps à la ligne 5 en plaçant la condition Temp < T[j-1] en premier.
Rappelez-vous qu’avec un « and », le second membre est évalué uniquement si le premier est « True ».

 Cas le plus défavorable (la liste est triée dans l’ordre inverse de celui souhaité)
Dans ce cas, il faut déterminer le nombre de fois que la boucle n°2 est exécutée. Ce dernier dépend de la valeur de
i :

Quand i = 1  1 fois
Quand i = 2  2 fois
. Total = 1 + 2 + 3 + …. + (n - 1) =
.
. ………………………………………….
Quand i = n – 1  n - 1 fois

Le résultat précédent est obtenu grâce à la somme des (n – 1) premiers termes d’une suite arithmétique

Ligne Nombre d’affectations Nombre de comparaisons Nombre d’opérations

1
2
3
4
5
6
7
8
Total

Coût total (n) =

………………
A savoir …
Dans le cas le plus défavorable, c'est-à-dire lorsque le tableau est déjà trié dans l’ordre inverse de celui
souhaité, la complexité est quadratique soit O(n²).

 Cas moyen
Pour obtenir la complexité dans ce cas, il suffit de faire la moyenne entre le cas le plus favorable et le cas le plus
défavorable :
Cas Coût
Le plus favorable
Le plus défavorable Coût moyen (n) =
…………………..

Conclusion
Avec une complexité moyenne quadratique O(n²), le tri par insertion n’est pas très performant lorsque les
données à trier sont importantes.

Cependant, du fait d’une complexité linéaire O(n) sur une liste déjà triée, il est l’un des plus rapide lorsque la
liste est pratiquement déjà triée, c’est pourquoi on le trouve souvent combiné à un tri fusion.

NSI Première 3 Tri par insertion

5. Terminaison de l’algorithme
Lorsque l’on utilise des boucles ou bien de la récursivité dans un programme, il est impératif de s’assurer que le
programme va bien s’arrêter à un moment donné et ne pas donner naissance à une « boucle infinie ».

Dans le cas du tri par insertion, nous utilisons deux boucles :

 Une boucle « for »,
 Une boucle « while ».

Une boucle « for » étant exécutée un nombre fini de fois (connu à l’avance) ne pose jamais de problème de
terminaison. Il n’en n’est pas de même pour la boucle « while » dont on ne connaît pas à l’avance le nombre de
fois qu’elle sera itérée. Pour prouver la terminaison de cette dernière, il faut prouver l’existence d’un
« convergent » :

Tant que j > 0 et Temp < T[j - 1]

T[j]  T[j - 1]
jj–1
Fin tant que

Le convergent est ici la variable j qui est initialisée à une valeur positive avant l’entrée dans la boucle puis
décrémentée ensuite dans la boucle. A un moment donné, j va donc « converger » vers 0 entrainant ainsi la sortie
de la boucle.

6. Correction de l’algorithme
Une fois que l’on a prouvé qu’un algorithme se termine effectivement, il reste à vérifier que celui-ci produit bien le
résultat attendu. Pour se faire, nous allons nous appuyer sur un principe mathématique que l’on appelle « la
démonstration par récurrence » d’une propriété de l’algorithme :

Etape Ce qu’il faut faire

Initialisation On démontre que la propriété est vraie au premier rang
Hérédité  On suppose que la propriété est vraie au rang n et on démontre qu’elle le reste au rang n
+ 1.
Conclusion On conclut que la propriété est vraie pour chaque rang n

La propriété que l’on cherche à démontrer s’appelle « un invariant de boucle », c'est-à-dire une propriété qui reste
vraie à chaque passage dans la boucle. En se basant sur le principe du tri par insertion qui consiste à  insérer un
élément dans une partie déjà triée, nous allons donc choisir comme invariant de boucle :

« Le tableau T[0 : i] est trié »

Initialisation (i = 1)
Le second élément du tableau est comparé avec le premier, s’il est plus grand, ils sont inversés. Au final, le tableau
T[0 : 1] est trié à la fin de la première boucle.

Hérédité
On suppose désormais que le tableau T[0 : i] est trié et on va démontrer que T[0 : i + 1] le sera aussi. L’élément
T[i + 1] est comparé avec ceux qui le précèdent. Tant que celui-ci est plus petit que celui qui le précède, il y a
inversion. Au final, l’élément T[i + 1] sera correctement positionné dans le tableau : le tableau T[0 : i + 1] sera
donc trié.

Conclusion
Quelle que soit la valeur de i, le tableau T[0 : i] est trié. Après exécution de la dernière boucle, le tableau sera donc
trié. Cela prouve la correction de l’algorithme de tri par insertion.

7. Stabilité
Supposons que l’on souhaite trier les carrés de couleurs ci-dessous selon la valeur qu’ils contiennent :

5 12 7 5 8 12

NSI Première 4 Tri par insertion

Avec un algorithme de tri instable, nous pourrons nous retrouver avec une situation finale comme celle qui est
indiquée ci-dessous :

5 5 7 8 12 12
On remarque que les carrés jaune et bleu, bien que de même valeur ont été inversés. Il en est de même pour les
carrés de valeur 12.

Un algorithme de tri stable respectera quant à lui l’ordre initial :

5 5 7 8 12 12

A tester …
Le tri par insertion est stable. Pour le vérifier, il suffit de modifier légèrement le programme afin qu’il puisse
effectuer le tri des carrés précédents : le carré jaune peut être représenté par [5, "Jaune"], …

8. Travail à effectuer
Ecriture de la fonction
 Ecrire une fonction Tri_insertion permettant de trier une liste de nombres par ordre croissant en appliquant le
principe du tri par insertion, puis appliquer cette fonction sur la liste [14, 7, 5, 15, 11, 64, 3, 9].

 Vérifier que cette fonction permet également de trier des mots en l’appliquant sur la liste  de mots ci-dessous
["Bonjour", "Chat", "Bonsoir", "Autruche", "Oie", "Chien"].

 Enregistrer le programme sous le nom « Tri par insertion (Ordre croissant).py »

Tests d’efficacité
Afin de vérifier les calculs précédents, nous allons générer une liste de nombres entiers aléatoires et mesurer le
temps nécessaire pour effectuer le tri en ajoutant dans le programme principal les lignes de code suivantes (vous
devrez faire un « import time » et un « import random » au préalable) :

 Ouvrez alors le fichier Excel « Performance des tris.xlxs » puis compléter-le.

 La courbe obtenue est-elle en accord avec les résultats des calculs de complexité :
...............................................................................................................................................................................................................................................................

 Ajouter l’instruction « liste.sort() » au programme afin que la liste soit triée avant que l’on ne lance le tri par
insertion, puis compléter le tableau Excel correspondant.

 Que remarquez-vous ?
...............................................................................................................................................................................................................................................................

Tri par ordre décroissant

 Modifier le programme précédent afin qu’il effectue un tri par ordre décroissant. Enregistrer le programme sous
le nom « Tri par insertion (Ordre décroissant).py »

Stabilité
 Vérifier la stabilité du tri par insertion en modifiant le programme précédent afin qu’il puisse effectuer le tri des
cubes ci-dessous :

5 12 7 5 8 12

Le premier cube est représenté par la liste [5, "Jaune"].

NSI Première 5 Tri par insertion

 Enregistrer votre programme sous le nom « Tri par insertion (Stabilité).py ».

NSI Première 6 Tri par insertion