Innsettingssortering er en enkel sorteringsalgoritme som fungerer ved å iterativt sette inn hvert element i en usortert liste på riktig plassering i en sortert del av listen. Det er en stabil sortering algoritme, som betyr at elementer med like verdier opprettholder sin relative rekkefølge i den sorterte utgangen.

Innsettingssortering er som å sortere spillekort i hendene. Du deler kortene i to grupper: de sorterte kortene og de usorterte kortene. Deretter velger du et kort fra den usorterte gruppen og legger det på riktig sted i den sorterte gruppen.

Algoritme for innsettingssortering:

Innsettingssortering er en enkel sorteringsalgoritme som fungerer ved å bygge en sortert matrise ett element om gangen. Det regnes som en på plass sorteringsalgoritme, noe som betyr at den ikke krever ekstra minneplass utover den opprinnelige matrisen.

Algoritme:

Følg disse trinnene for å oppnå innsettingssortering:

hvor gammel er pete davidson

• Vi må starte med det andre elementet i matrisen da første element i matrisen antas å være sortert.
• Sammenlign det andre elementet med det første elementet og sjekk om det andre elementet er mindre, og bytt dem deretter.
• Flytt til det tredje elementet og sammenlign det med det andre elementet, deretter det første elementet og bytt om nødvendig for å sette det i riktig posisjon blant de tre første elementene.
• Fortsett denne prosessen, sammenlign hvert element med de før det og bytt etter behov for å plassere det i riktig posisjon blant de sorterte elementene.
• Gjenta til hele matrisen er sortert.

Virkemåte for innsettingssortering:

Tenk på en matrise som har elementer : {23, 1, 10, 5, 2}

Første pass:

• Nåværende element er 23
• Det første elementet i matrisen antas å være sortert.
• Den sorterte delen til 0 indeksen er: [23]

Andre pass:

• Sammenligne 1 med 23 (nåværende element med den sorterte delen).
• Siden 1 er mindre, sett inn 1 før 23 .
• Den sorterte delen til 1 indeksen er: [1, 23]

Tredje pass:

java string.format

• Sammenligne 10 med 1 og 23 (nåværende element med den sorterte delen).
• Siden 10 er større enn 1 og mindre enn 23 , sett inn 10 mellom 1 og 23 .
• Den sorterte delen til 2 indeksen er: [1, 10, 23]

Fjerde pass:

• Sammenligne 5 med 1 , 10 , og 23 (nåværende element med den sorterte delen).
• Siden 5 er større enn 1 og mindre enn 10 , sett inn 5 mellom 1 og 10 .
• Den sorterte delen til 3 indeks er : [1, 5, 10, 23]

Femte pass:

git status -s

• Sammenligne 2 med 1, 5, 10 , og 23 (nåværende element med den sorterte delen).
• Siden 2 er større enn 1 og mindre enn 5 sett inn 2 mellom 1 og 5 .
• Den sorterte delen til 4 indeksen er: [1, 2, 5, 10, 23]

Endelig matrise:

• Den sorterte matrisen er: [1, 2, 5, 10, 23]

Implementering av innsettingssortering:

// 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]> tast) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = nøkkel;  } } // En verktøyfunksjon for å skrive ut en matrise // av størrelse n void printArray(int arr[], int n) { int i;  for (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]> tast) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = nøkkel;  } } // En verktøyfunksjon for å skrive ut en matrise med størrelse n void printArray(int arr[], int n) { int i;  for (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]> tast) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = nøkkel;  } } /* En verktøyfunksjon for å skrive ut array av størrelse n*/ static void printArray(int arr[]) { int n = arr.length;  for (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 og tast< 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]> tast) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = nøkkel;  } } // En verktøyfunksjon for å skrive ut // array av størrelse n static void printArray(int[] arr) { int n = arr.Length;  for (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]> $key) { $arr[$j + 1] = $arr[$j]; $j = $j - 1; } $arr[$j + 1] = $nøkkel; } } // En verktøyfunksjon for å // skrive ut en matrise med størrelse n funksjon 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>

Tidskompleksitet: O(N^2)
Hjelpeplass: O(1)

Kompleksitetsanalyse av innsettingssortering :

Tidskompleksitet for innsettingssortering

• Beste tilfelle: På) , Hvis listen allerede er sortert, hvor n er antall elementer i listen.
• Gjennomsnittlig tilfelle: På ² ) , Hvis listen er tilfeldig ordnet
• Verste tilfelle: På ² ) , Hvis listen er i omvendt rekkefølge

Plass kompleksitet av innsettingssort

• Hjelpeplass: O(1), Innsettingssortering krever O(1) ekstra plass, noe som gjør det til en plasseffektiv sorteringsalgoritme.

Fordeler av innsettingssort:

• Enkel og lett å implementere.
• Stabil sorteringsalgoritme.
• Effektiv for små lister og nesten sorterte lister.
• Plasseffektiv.

Ulemper av innsettingssort:

• Ineffektiv for store lister.
• Ikke like effektive som andre sorteringsalgoritmer (f.eks. sammenslåingssortering, rask sortering) i de fleste tilfeller.

applikasjoner av innsettingssort:

Innsettingssortering brukes ofte i situasjoner der:

• Listen er liten eller nesten sortert.
• Enkelhet og stabilitet er viktig.

Ofte stilte spørsmål om innsettingssortering

Q1. Hva er grensetilfellene til algoritmen for innsettingssortering?

Innsettingssortering tar maksimal tid å sortere hvis elementer er sortert i omvendt rekkefølge. Og det tar minimum tid (Rekkefølge på n) når elementene allerede er sortert.

Q2. Hva er det algoritmiske paradigmet til algoritmen for innsettingssortering?

Algoritmen for innsettingssortering følger en inkrementell tilnærming.

Q3. Er innsettingssortering en in-place sorteringsalgoritme?

chr funksjon python

Ja, innsettingssortering er en in-place sorteringsalgoritme.

Q4. Er Insertion Sort en stabil algoritme?

Ja, innsettingssortering er en stabil sorteringsalgoritme.

Q5. Når brukes algoritmen for innsettingssortering?

hiba bukhari

Innsettingssortering brukes når antall elementer er lite. Det kan også være nyttig når input-arrayen er nesten sortert, og bare noen få elementer er feilplassert i en komplett stor matrise.