Tri par insertion est un algorithme de tri simple qui fonctionne en insérant de manière itérative chaque élément d'une liste non triée à sa position correcte dans une partie triée de la liste. C'est un tri stable algorithme, ce qui signifie que les éléments avec des valeurs égales conservent leur ordre relatif dans la sortie triée.

Tri par insertion c'est comme trier des cartes à jouer entre vos mains. Vous divisez les cartes en deux groupes : les cartes triées et les cartes non triées. Ensuite, vous choisissez une carte dans le groupe non trié et la placez au bon endroit dans le groupe trié.

Algorithme de tri par insertion :

Tri par insertion est un algorithme de tri simple qui fonctionne en construisant un tableau trié, un élément à la fois. Il est considéré comme un en place algorithme de tri, ce qui signifie qu’il ne nécessite aucun espace mémoire supplémentaire au-delà du tableau d’origine.

top 10 hentaï

Algorithme:

Pour réaliser le tri par insertion, procédez comme suit :

• Nous devons commencer par le deuxième élément du tableau car le premier élément du tableau est supposé être trié.
• Comparez le deuxième élément avec le premier élément et vérifiez si le deuxième élément est plus petit, puis échangez-les.
• Passez au troisième élément et comparez-le avec le deuxième élément, puis avec le premier élément et échangez si nécessaire pour le mettre dans la bonne position parmi les trois premiers éléments.
• Continuez ce processus, en comparant chaque élément avec ceux qui le précèdent et en les échangeant si nécessaire pour le placer dans la bonne position parmi les éléments triés.
• Répétez jusqu'à ce que l'ensemble du tableau soit trié.

Fonctionnement de l'algorithme de tri par insertion :

Considérons un tableau contenant des éléments : {23, 1, 10, 5, 2}

Premier passage:

• L'élément actuel est 23
• Le premier élément du tableau est supposé être trié.
• La partie triée jusqu'à 0ème l'indice est : [23]

Deuxième passage :

• Comparer 1 avec 23 (élément courant avec la partie triée).
• Depuis 1 est plus petit, insérez 1 avant 23 .
• La partie triée jusqu'à 1er l'indice est : [1, 23]

Troisième passage :

• Comparer dix avec 1 et 23 (élément courant avec la partie triée).
• Depuis dix est supérieur à 1 et plus petit que 23 , insérer dix entre 1 et 23 .
• La partie triée jusqu'à 2ème l'indice est : [1, 10, 23]

Quatrième passe :

• Comparer 5 avec 1 , dix , et 23 (élément courant avec la partie triée).
• Depuis 5 est supérieur à 1 et plus petit que dix , insérer 5 entre 1 et dix .
• La partie triée jusqu'à 3ème l'indice est : [1, 5, 10, 23]

Cinquième passe :

• Comparer 2 avec 1, 5, 10 , et 23 (élément courant avec la partie triée).
• Depuis 2 est supérieur à 1 et plus petit que 5 insérer 2 entre 1 et 5 .
• La partie triée jusqu'à 4ème l'indice est : [1, 2, 5, 10, 23]

Tableau final :

• Le tableau trié est : [1, 2, 5, 10, 23]

Implémentation du tri par insertion :

// C++ program for insertion sort #include  using namespace std; // Function to sort an array using // insertion sort void insertionSort(int arr[], int n) {  int i, key, j;  for (i = 1; i < n; i++) {  key = arr[i];  j = i - 1;  // Move elements of arr[0..i-1],  // that are greater than key,   // to one position ahead of their  // current position  while (j>= 0 && arr[j]> clé) { arr[j + 1] = arr[j];  j = j - 1 ;  } arr[j + 1] = clé ;  } } // Une fonction utilitaire pour imprimer un tableau // de taille n void printArray(int arr[], int n) { int i;  pour (je = 0; je< n; i++)  cout << arr[i] << ' ';  cout << endl; } // Driver code int main() {  int arr[] = { 12, 11, 13, 5, 6 };  int N = sizeof(arr) / sizeof(arr[0]);  insertionSort(arr, N);  printArray(arr, N);  return 0; } // This is code is contributed by rathbhupendra>

// C program for insertion sort #include  #include  /* Function to sort an array using insertion sort*/ void insertionSort(int arr[], int n) {  int i, key, j;  for (i = 1; i < n; i++) {  key = arr[i];  j = i - 1;  /* Move elements of arr[0..i-1], that are  greater than key, to one position ahead  of their current position */  while (j>= 0 && arr[j]> clé) { arr[j + 1] = arr[j];  j = j - 1 ;  } arr[j + 1] = clé ;  } } // Une fonction utilitaire pour imprimer un tableau de taille n void printArray(int arr[], int n) { int i;  pour (je = 0; je< n; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver program to test insertion sort */ int main() {  int arr[] = { 12, 11, 13, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  insertionSort(arr, n);  printArray(arr, n);  return 0; }>

// Java program for implementation of Insertion Sort public class InsertionSort {  /*Function to sort array using insertion sort*/  void sort(int arr[])  {  int n = arr.length;  for (int i = 1; i < n; ++i) {  int key = arr[i];  int j = i - 1;  /* Move elements of arr[0..i-1], that are  greater than key, to one position ahead  of their current position */  while (j>= 0 && arr[j]> clé) { arr[j + 1] = arr[j];  j = j - 1 ;  } arr[j + 1] = clé ;  } } /* Une fonction utilitaire pour imprimer un tableau de taille n*/ static void printArray(int arr[]) { int n = arr.length;  pour (int je = 0; je< n; ++i)  System.out.print(arr[i] + ' ');  System.out.println();  }  // Driver method  public static void main(String args[])  {  int arr[] = { 12, 11, 13, 5, 6 };  InsertionSort ob = new InsertionSort();  ob.sort(arr);  printArray(arr);  } }; /* This code is contributed by Rajat Mishra. */>

# Python program for implementation of Insertion Sort # Function to do insertion sort def insertionSort(arr): # Traverse through 1 to len(arr) for i in range(1, len(arr)): key = arr[i] # Move elements of arr[0..i-1], that are # greater than key, to one position ahead # of their current position j = i-1 while j>= 0 et clé< arr[j] : arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key # Driver code to test above arr = [12, 11, 13, 5, 6] insertionSort(arr) for i in range(len(arr)): print ('% d' % arr[i]) # This code is contributed by Mohit Kumra>

// C# program for implementation of Insertion Sort using System; class InsertionSort {  // Function to sort array  // using insertion sort  void sort(int[] arr)  {  int n = arr.Length;  for (int i = 1; i < n; ++i) {  int key = arr[i];  int j = i - 1;  // Move elements of arr[0..i-1],  // that are greater than key,  // to one position ahead of  // their current position  while (j>= 0 && arr[j]> clé) { arr[j + 1] = arr[j];  j = j - 1 ;  } arr[j + 1] = clé ;  } } // Une fonction utilitaire pour imprimer // un tableau de taille n static void printArray(int[] arr) { int n = arr.Length;  pour (int je = 0; je< n; ++i)  Console.Write(arr[i] + ' ');  Console.Write('
');  }  // Driver Code  public static void Main()  {  int[] arr = { 12, 11, 13, 5, 6 };  InsertionSort ob = new InsertionSort();  ob.sort(arr);  printArray(arr);  } } // This code is contributed by ChitraNayal.>

>

 // PHP program for insertion sort // Function to sort an array // using insertion sort function insertionSort(&$arr, $n) { for ($i = 1; $i < $n; $i++) { $key = $arr[$i]; $j = $i-1; // Move elements of arr[0..i-1], // that are greater than key, to  // one position ahead of their  // current position while ($j>= 0 && $arr[$j]> $clé) { $arr[$j + 1] = $arr[$j]; $j = $j - 1 ; } $arr[$j + 1] = $clé; } } // Une fonction utilitaire pour // imprimer un tableau de taille n function printArray(&$arr, $n) { for ($i = 0; $i< $n; $i++) echo $arr[$i].' '; echo '
'; } // Driver Code $arr = array(12, 11, 13, 5, 6); $n = sizeof($arr); insertionSort($arr, $n); printArray($arr, $n); // This code is contributed by ChitraNayal. ?>>

5 6 11 12 13>

Complexité temporelle : O(N^2)
Espace auxiliaire : O(1)

Analyse de complexité du tri par insertion :

Complexité temporelle du tri par insertion

• Meilleur cas: Sur) , Si la liste est déjà triée, où n est le nombre d'éléments dans la liste.
• Cas moyen : Sur ² ) , Si la liste est ordonnée au hasard
• Pire cas: Sur ² ) , Si la liste est dans l'ordre inverse

Complexité spatiale du tri par insertion

• Espace auxiliaire : O(1), Le tri par insertion nécessite O(1) espace supplémentaire, ce qui en fait un algorithme de tri économe en espace.

Avantages du tri par insertion :

• Simple et facile à mettre en œuvre.
• Algorithme de tri stable.
• Efficace pour les petites listes et les listes presque triées.
• Gain de place.

Désavantages du tri par insertion :

• Inefficace pour les grandes listes.
• Pas aussi efficace que d'autres algorithmes de tri (par exemple, tri par fusion, tri rapide) dans la plupart des cas.

Applications du tri par insertion :

Le tri par insertion est couramment utilisé dans les situations où :

• La liste est petite ou presque triée.
• La simplicité et la stabilité sont importantes.

Foire aux questions sur le tri par insertion

T1. Quels sont les cas limites de l’algorithme de tri par insertion ?

introduction java

Le tri par insertion prend le temps maximum pour trier si les éléments sont triés dans l'ordre inverse. Et cela prend un minimum de temps (Ordre de n) lorsque les éléments sont déjà triés.

Q2. Quel est le paradigme algorithmique de l’algorithme de tri par insertion ?

cas de test Junit

L’algorithme de tri par insertion suit une approche incrémentale.

Q3. Le tri par insertion est-il un algorithme de tri sur place ?

Oui, le tri par insertion est un algorithme de tri sur place.

Q4. Le tri par insertion est-il un algorithme stable ?

Oui, le tri par insertion est un algorithme de tri stable.

Q5. Quand l’algorithme de tri par insertion est-il utilisé ?

Le tri par insertion est utilisé lorsque le nombre d'éléments est petit. Cela peut également être utile lorsque le tableau d'entrée est presque trié et que seuls quelques éléments sont égarés dans un grand tableau complet.