Classificació per inserció és un algorisme d'ordenació senzill que funciona inserint iterativament cada element d'una llista sense ordenar a la seva posició correcta en una part ordenada de la llista. És un classificació estable algorisme, el que significa que els elements amb valors iguals mantenen el seu ordre relatiu a la sortida ordenada.

Classificació per inserció és com ordenar les cartes a les mans. Dividiu les cartes en dos grups: les cartes ordenades i les cartes sense classificar. A continuació, trieu una targeta del grup sense classificar i la col·loqueu al lloc correcte del grup ordenat.

Algorisme d'ordenació d'inserció:

Classificació per inserció és un algorisme d'ordenació senzill que funciona construint una matriu ordenada un element a la vegada. Es considera un en el seu lloc algorisme d'ordenació, el que significa que no requereix cap espai de memòria addicional més enllà de la matriu original.

Algorisme:

Per aconseguir l'ordenació per inserció, seguiu aquests passos:

• Hem de començar amb el segon element de la matriu, ja que se suposa que el primer element de la matriu està ordenat.
• Compareu el segon element amb el primer i comproveu si el segon element és més petit i després intercanvieu-los.
• Passeu al tercer element i compareu-lo amb el segon element, després el primer element i canvieu-lo segons sigui necessari per posar-lo a la posició correcta entre els tres primers elements.
• Continueu aquest procés, comparant cada element amb els anteriors i canviant-lo segons sigui necessari per col·locar-lo a la posició correcta entre els elements ordenats.
• Repetiu fins que s'ordena tota la matriu.

Funcionament de l'algoritme d'ordenació d'inserció:

Considereu una matriu que té elements : {23, 1, 10, 5, 2}

Primera passada:

• L'element actual és 23
• Se suposa que el primer element de la matriu està ordenat.
• La part ordenada fins 0è índex és: [23]

Segona passada:

• Compara 1 amb 23 (element actual amb la part ordenada).
• Des que 1 és més petit, inseriu-lo 1 abans 23 .
• La part ordenada fins 1r índex és: [1, 23]

Tercera passada:

• Compara 10 amb 1 i 23 (element actual amb la part ordenada).
• Des que 10 és més gran que 1 i més petit que 23 , inserir 10 entre 1 i 23 .
• La part ordenada fins 2n índex és: [1, 10, 23]

Quarta passada:

• Compara 5 amb 1 , 10 , i 23 (element actual amb la part ordenada).
• Des que 5 és més gran que 1 i més petit que 10 , inserir 5 entre 1 i 10 .
• La part ordenada fins 3r índex és : [1, 5, 10, 23]

Cinquena passada:

• Compara 2 amb 1, 5, 10 , i 23 (element actual amb la part ordenada).
• Des que 2 és més gran que 1 i més petit que 5 inserir 2 entre 1 i 5 .
• La part ordenada fins 4t índex és: [1, 2, 5, 10, 23]

Matriu final:

• La matriu ordenada és: [1, 2, 5, 10, 23]

Implementació de l'ordenació d'inserció:

// 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]> tecla) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = clau;  } } // Una funció d'utilitat per imprimir una matriu // de mida n void printArray(int arr[], int n) { int i;  per (i = 0; i< 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]> tecla) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = clau;  } } // Una funció d'utilitat per imprimir una matriu de mida n void printArray(int arr[], int n) { int i;  per (i = 0; i< 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]> tecla) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = clau;  } } /* Una funció d'utilitat per imprimir una matriu de mida n*/ static void printArray(int arr[]) { int n = arr.length;  per (int i = 0; i< 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 i clau< 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]> tecla) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = clau;  } } // Una funció d'utilitat per imprimir // matriu de mida n static void printArray(int[] arr) { int n = arr.Length;  per (int i = 0; i< 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]> $clau) { $arr[$j + 1] = $arr[$j]; $j = $j - 1; } $arr[$j + 1] = $clau; } } // Una funció d'utilitat per // imprimir una matriu de mida n function printArray(&$arr, $n) { per ($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>

Complexitat temporal: O(N^2)
Espai auxiliar: O(1)

Anàlisi de complexitat de la classificació d'inserció :

Complexitat temporal de l'ordenació d'inserció

• Millor cas: O(n) , Si la llista ja està ordenada, on n és el nombre d'elements de la llista.
• Cas mitjà: O (n ² ) , Si la llista està ordenada aleatòriament
• Pitjor dels casos: O (n ² ) , Si la llista està en ordre invers

Complexitat espacial d'Ordenació d'inserció

• Espai auxiliar: O(1), l'ordenació d'inserció requereix O(1) espai addicional, convertint-lo en un algorisme d'ordenació eficient en l'espai.

Avantatges d'ordenació d'inserció:

• Simple i fàcil d'implementar.
• Algorisme d'ordenació estable.
• Eficaç per a llistes petites i llistes gairebé ordenades.
• Espai eficient.

Desavantatges d'ordenació d'inserció:

• Ineficient per a llistes grans.
• No és tan eficient com altres algorismes d'ordenació (p. ex., ordenació combinada, ordenació ràpida) en la majoria dels casos.

Aplicacions d'Ordenació d'inserció:

L'ordenació per inserció s'utilitza habitualment en situacions en què:

• La llista és petita o gairebé ordenada.
• La senzillesa i l'estabilitat són importants.

Preguntes freqüents sobre l'ordenació d'inserció

Q1. Quins són els casos límit de l'algorisme d'ordenació d'inserció?

L'ordenació per inserció triga el temps màxim a ordenar si els elements s'ordenen en ordre invers. I es necessita un temps mínim (Ordre de n) quan els elements ja estan ordenats.

P2. Quin és el paradigma algorítmic de l'algoritme d'ordenació d'inserció?

L'algorisme d'ordenació d'inserció segueix un enfocament incremental.

P3. Insertion Sort és un algorisme d'ordenació in situ?

Sí, l'ordenació per inserció és un algorisme d'ordenació local.

arp - una ordre

P4. És Insertion Sort un algorisme estable?

Sí, l'ordenació per inserció és un algorisme d'ordenació estable.

P5. Quan s'utilitza l'algoritme d'ordenació d'inserció?

L'ordenació per inserció s'utilitza quan el nombre d'elements és petit. També pot ser útil quan la matriu d'entrada està gairebé ordenada i només uns quants elements estan fora de lloc en una matriu gran completa.