Invoegsoort is een eenvoudig sorteeralgoritme dat werkt door elk element van een ongesorteerde lijst iteratief op de juiste positie in een gesorteerd deel van de lijst in te voegen. Het is een stabiele sortering algoritme, wat betekent dat elementen met gelijke waarden hun relatieve volgorde in de gesorteerde uitvoer behouden.

Invoegsoort is als het sorteren van speelkaarten in je handen. Je deelt de kaarten op in twee groepen: de gesorteerde kaarten en de ongesorteerde kaarten. Vervolgens kies je een kaart uit de ongesorteerde groep en leg je deze op de juiste plaats in de gesorteerde groep.

Algoritme voor invoegsortering:

Invoegsoort is een eenvoudig sorteeralgoritme dat werkt door een gesorteerde array element voor element op te bouwen. Het wordt beschouwd als een in situ sorteeralgoritme, wat betekent dat er geen extra geheugenruimte nodig is buiten de oorspronkelijke array.

Algoritme:

Volg deze stappen om een ​​invoegsortering te bereiken:

k naaste buur

• We moeten beginnen met het tweede element van de array, omdat wordt aangenomen dat het eerste element in de array is gesorteerd.
• Vergelijk het tweede element met het eerste element, controleer of het tweede element kleiner is en verwissel ze vervolgens.
• Ga naar het derde element en vergelijk het met het tweede element, daarna met het eerste element en verwissel indien nodig om het op de juiste positie tussen de eerste drie elementen te plaatsen.
• Ga door met dit proces, vergelijk elk element met de voorgaande en wissel indien nodig om het op de juiste positie tussen de gesorteerde elementen te plaatsen.
• Herhaal dit totdat de hele array is gesorteerd.

Werking van het invoegsorteeralgoritme:

Beschouw een array met elementen : {23, 1, 10, 5, 2}

Eerste Paas:

• Huidig ​​element is 23
• Er wordt aangenomen dat het eerste element in de array is gesorteerd.
• Het gesorteerde deel tot 0e index is: [23]

Tweede pas:

• Vergelijken 1 met 23 (huidig ​​element met het gesorteerde onderdeel).
• Sinds 1 is kleiner, invoegen 1 voor 23 .
• Het gesorteerde deel tot 1e index is: [1, 23]

Derde pas:

• Vergelijken 10 met 1 En 23 (huidig ​​element met het gesorteerde onderdeel).
• Sinds 10 is groter dan 1 en kleiner dan 23 , invoegen 10 tussen 1 En 23 .
• Het gesorteerde deel tot 2e index is: [1, 10, 23]

Vierde pas:

• Vergelijken 5 met 1 , 10 , En 23 (huidig ​​element met het gesorteerde onderdeel).
• Sinds 5 is groter dan 1 en kleiner dan 10 , invoegen 5 tussen 1 En 10 .
• Het gesorteerde deel tot 3e indexering is : [1, 5, 10, 23]

Vijfde pas:

Java-programmeerpatronen

• Vergelijken 2 met 1, 5, 10 , En 23 (huidig ​​element met het gesorteerde onderdeel).
• Sinds 2 is groter dan 1 en kleiner dan 5 invoegen 2 tussen 1 En 5 .
• Het gesorteerde deel tot 4e index is: [1, 2, 5, 10, 23]

Laatste reeks:

• De gesorteerde array is: [1, 2, 5, 10, 23]

Implementatie van invoegsortering:

// 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]> sleutel) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = sleutel;  } } // Een hulpprogrammafunctie om een ​​array // met de grootte n void printArray(int arr[], int n) { int i;  voor (i = 0; ik< 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]> sleutel) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = sleutel;  } } // Een hulpprogrammafunctie voor het afdrukken van een array met de grootte n void printArray(int arr[], int n) { int i;  voor (i = 0; ik< 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]> sleutel) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = sleutel;  } } /* Een hulpprogrammafunctie voor het afdrukken van een array met de grootte n*/ static void printArray(int arr[]) { int n = arr.length;  voor (int i = 0; ik< 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 en sleutel< 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]> sleutel) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = sleutel;  } } // Een hulpprogrammafunctie om af te drukken // array van grootte n static void printArray(int[] arr) { int n = arr.Length;  voor (int i = 0; ik< 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]> $sleutel) { $arr[$j + 1] = $arr[$j]; $j = $j - 1; } $arr[$j + 1] = $sleutel; } } // Een hulpprogrammafunctie om // een array af te drukken met de grootte 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>

Tijdcomplexiteit: O(N^2)
Hulpruimte: O(1)

Complexiteitsanalyse van invoegsortering :

Tijdcomplexiteit van invoegsortering

• Beste geval: Op) , Als de lijst al is gesorteerd, waarbij n het aantal elementen in de lijst is.
• Gemiddeld geval: Op ² ) , Als de lijst willekeurig is gerangschikt
• Het slechtste geval: Op ² ) , Als de lijst in omgekeerde volgorde staat

Ruimtecomplexiteit van invoegsortering

• Hulpruimte: O(1), Invoegsortering vereist O(1) extra ruimte, waardoor het een ruimtebesparend sorteeralgoritme is.

Voordelen van invoegsoort:

• Eenvoudig en gemakkelijk te implementeren.
• Stabiel sorteeralgoritme.
• Efficiënt voor kleine lijsten en bijna gesorteerde lijsten.
• Ruimtebesparend.

Nadelen van invoegsoort:

• Inefficiënt voor grote lijsten.
• In de meeste gevallen niet zo efficiënt als andere sorteeralgoritmen (bijvoorbeeld samenvoegen, snel sorteren).

Toepassingen van invoegsoort:

Invoegsortering wordt vaak gebruikt in situaties waarin:

• De lijst is klein of bijna gesorteerd.
• Eenvoud en stabiliteit zijn belangrijk.

Veelgestelde vragen over invoegsortering

Q1. Wat zijn de grensgevallen van het Insertion Sort-algoritme?

Java is leeg

Invoegsortering kost de maximale tijd om te sorteren als elementen in omgekeerde volgorde worden gesorteerd. En het kost minimale tijd (volgorde van n) als de elementen al zijn gesorteerd.

Vraag 2. Wat is het algoritmische paradigma van het invoegsorteeralgoritme?

Het Insertion Sort-algoritme volgt een incrementele benadering.

Q3. Is Insertion Sort een in-place sorteeralgoritme?

Ja, invoegsortering is een in-place sorteeralgoritme.

Q4. Is Insertion Sort een stabiel algoritme?

imessage-spellen op Android

Ja, invoegsortering is een stabiel sorteeralgoritme.

Vraag 5. Wanneer wordt het Insertion Sort-algoritme gebruikt?

Invoegsortering wordt gebruikt als het aantal elementen klein is. Het kan ook handig zijn als de invoerarray bijna is gesorteerd en slechts een paar elementen misplaatst zijn in een complete grote array.