Combinaison avec d'autres tris
En pratique, sur les petites entrées, en dessous d'une taille critique K (qui dépend de l'implémentation et de la machine utilisée), les algorithmes de tri en basés sur la méthode « diviser pour régner » ( tri fusion, tri rapide) sont moins efficaces que le tri par insertion. Dans ce type d'algorithmes, plutôt que de diviser récursivement l'entrée jusqu'à avoir des sous-problèmes élémentaires de taille 1 ou 2, on peut s'arrêter dès que les sous-problèmes ont une taille inférieure à K et les traiter avec le tri par insertion. Pour le cas particulier du tri rapide, une variante plus efficace existe [ 3]:
exécuter d'abord le tri rapide en ignorant simplement les sous-problèmes de taille inférieure à K;
faire un tri par insertion sur le tableau complet à la fin, ce qui est rapide car la liste est déjà presque triée. Voir aussi
(en) Illustration dynamique du tri par insertion
Notes et références
↑ (en) Sedgewick, Robert, Algorithms., Addison-Wesley, 1983 ( ISBN 978-0-201-06672-2), p. 95
↑ a et b (en) Donald E. Knuth, The Art of Computer Programming, vol.
- Trie par insertion machine
- Trie par insertion professionnelle des jeunes
- Tri par insertion langage c
- Tri par insertion en c
- Tri par insertion c
Trie Par Insertion Machine
Tri par insertion
Thibault Allançon
Articles
Publié: 01/05/2014 · Modifié: 08/12/2015
Introduction
Le tri par insertion ( insertion sort en anglais) est un algorithme de tri par comparaison simple, et intuitif mais toujours avec une complexité en \(O(N^2)\). Vous l'avez sans doute déjà utilisé sans même vous en rendre compte: lorsque vous triez des cartes par exemple. C'est un algorithme de tri stable, en place, et le plus rapide en pratique sur une entrée de petite taille. Principe de l'algorithme
Le principe du tri par insertion est de trier les éléments du tableau comme avec des cartes:
On prend nos cartes mélangées dans notre main. On crée deux ensembles de carte, l'un correspond à l'ensemble de carte triée, l'autre contient l'ensemble des cartes restantes (non triées). On prend au fur et à mesure, une carte dans l'ensemble non trié et on l'insère à sa bonne place dans l'ensemble de carte triée. On répète cette opération tant qu'il y a des cartes dans l'ensemble non trié. Exemple
Prenons comme exemple la suite de nombre suivante: 9, 2, 7, 1 que l'on veut trier en ordre croissant avec l'algorithme du tri par insertion:
1er tour:
9 | 2, 7, 1 -> à gauche la partie triée du tableau (le premier élément est considéré comme trié puisqu'il est seul dans cette partie), à droite la partie non triée.
Trie Par Insertion Professionnelle Des Jeunes
C'est le tri du joueur de cartes. On fait comme si les éléments à trier étaient donnés un par un, le premier élément constituant, à lui tout seul, une liste triée de longueur 1. On range ensuite le second élément pour constituer une liste triée de longueur 2, puis on range le troisième élément pour avoir une liste triée de longueur 3 et ainsi de suite... Le principe du tri par insertion est donc d'insérer à la n ième itération le n ième élément à la bonne place. L'animation ci-après illustre le fonctionnement de ce tri: Démonstration du tri par insertion Pseudo-code Caml Pascal Python C Graphique Schéma PROCEDURE tri_Insertion ( Tableau a [ 1: n]) POUR i VARIANT DE 2 A n FAIRE INSERER a [ i] à sa place dans a [ 1: i - 1]; FIN PROCEDURE; let tri_insertion tableau = for i = 1 to 19 do let en_cours = tableau. ( i) and j = ref ( i - 1) in (* Décalage des éléments du tableau *) while (! j >= 0) && ( tableau. (! j) > en_cours) do tableau. (! j + 1) <- tableau. (! j); j:=! j - 1; done; (* on insère l'élément à sa place *) tableau.
Tri Par Insertion Langage C
Décaler les éléments de la partie triée prend \(i\) tours (avec \(i\) variant de 0 à \(N\)). Dans le pire des cas on parcourt \(N^2\) tours, donc le tri par insertion a une complexité en temps de \(O(N^2)\). Implémentation
L'implémentation en C du tri par insertion:
tri_insertion. c
#include
Tri Par Insertion En C
Il échange 33 contre 27. Il vérifie également avec tous les éléments de la sous-liste triée. Ici, nous voyons que la sous-liste triée n'a qu'un seul élément 14, et 27 est supérieur à 14. Par conséquent, la sous-liste triée reste triée après l'échange. À présent, nous avons 14 et 27 dans la sous-liste triée. Ensuite, il compare 33 à 10. Ces valeurs ne sont pas triées. Nous les échangeons donc. Cependant, l'échange rend 27 et 10 non triés. Par conséquent, nous les échangeons aussi. Encore une fois, nous trouvons 14 et 10 dans un ordre non trié. Nous les échangeons à nouveau. À la fin de la troisième itération, nous avons une sous-liste triée de 4 éléments. Ce processus se poursuit jusqu'à ce que toutes les valeurs non triées soient couvertes dans une sous-liste triée. Nous allons maintenant voir quelques aspects de programmation du tri par insertion. Algorithme
Nous avons maintenant une vue d'ensemble du fonctionnement de cette technique de tri, nous pouvons donc en déduire des étapes simples grâce auxquelles nous pouvons réaliser le tri par insertion.
Tri Par Insertion C
D) Complexité:
Choisissons comme opération élémentaire
la comparaison de deux cellules
du tableau. Dans le pire des cas le nombre de comparaisons " Tantque Tab[ j-1] > v faire " est une valeur qui ne dépend que
de la longueur i de la partie ( a 1, a 2,..., a i)
déjà rangée. Il y a donc au pire i comparaisons pour
chaque i variant de 2 à n:
La complexité au pire en nombre de comparaison est donc égale
à la somme des n termes suivants (i = 2, i = 3,.... i = n)
C = 2 + 3 + 4 +... + n = n(n+1)/2 -1 comparaisons au maximum. (c'est
la somme des n premiers entiers moins 1). La complexité au pire en nombre de comparaison est de de l'ordre
de n², que l'on écrit O(n²). Choisissons maintenant comme opération élémentaire
le transfert d'une cellule du tableau. Calculons par dénombrement du nombre de transferts dans le pire
des cas.
\(i_{max} = \frac{n}{2}\)
\(i_{max} = 1\)
\(i_{max} = \log_3(n)\)
\(i_{max} = n + 3 \times (n-1)\)
\(i_{max} = \log_2(n)\)
\(i_{max} = \log_3(n-1)\)
\(i_{max} = 3^n\)
\(i_{max} = n\)
\(i_{max} = \frac{n}{3}\)
\(i_{max} = n \times \log(n)\)
\(i_{max} = 2^n\)
Quelle est la complexité temporelle de la fonction insertion_sort_h obtenue en résolvant les équations de récurrence de cette fonction? Sélectionnez, parmi les réponses proposées, la complexité temporelle représentée par la notation \(\Omega(. ), \Theta(. ), O(. )\) la plus appropriée pour décrire cette complexité. À tout hasard, sachez que d'après une source de fiabilité discutable, \(\sum_{i = 1}^{n} i^2 = \frac{n \times (n+1) \times (2n + 1)}{6}\). Ça pourrait vous être utile. Néanmoins, si vous en avez besoin, il serait bon de prouver (par induction) ce résultat. \(\Theta(n^3)\)
\(O(n^3)\)
\(O(2^n+n)\)
\(O(2^n)\)
\(\Theta(n^2)\)
\(\Theta(2^n)\)
\(O(n^n)\)
\(O(n^2 \log(n))\)
\(O(n^2)\)
\(\Theta(n-1)\)
\(\Theta(n^2 \log(n))\)
\(\Theta(\frac{n}{2})\)