Razvrstitev vstavljanja je preprost algoritem za razvrščanje, ki deluje tako, da vsak element nerazvrščenega seznama iterativno vstavi na pravilno mesto v razvrščenem delu seznama. Je stabilno sortiranje algoritem, kar pomeni, da elementi z enakimi vrednostmi ohranijo svoj relativni vrstni red v razvrščenem izhodu.

java volatile ključna beseda

Razvrstitev vstavljanja je kot razvrščanje igralnih kart v rokah. Karte razdelite v dve skupini: razvrščene karte in nerazvrščene karte. Nato izberete karto iz nerazvrščene skupine in jo postavite na pravo mesto v razvrščeni skupini.

Algoritem za razvrščanje vstavljanja:

Razvrstitev vstavljanja je preprost algoritem za razvrščanje, ki deluje tako, da gradi razvrščeno matriko en element naenkrat. Šteje se za na mestu algoritem za razvrščanje, kar pomeni, da ne potrebuje dodatnega pomnilniškega prostora poleg izvirnega polja.

Algoritem:

Če želite doseči razvrščanje z vstavljanjem, sledite tem korakom:

• Začeti moramo z drugim elementom matrike, saj se predpostavlja, da je prvi element v matriki razvrščen.
• Primerjaj drugi element s prvim in preveri, ali je drugi manjši, nato ju zamenjaj.
• Premaknite se na tretji element in ga primerjajte z drugim elementom, nato s prvim elementom in po potrebi zamenjajte, da ga postavite na pravilen položaj med prvimi tremi elementi.
• Nadaljujte s tem postopkom, tako da vsak element primerjate s tistimi pred njim in po potrebi zamenjate, da ga postavite na pravilen položaj med razvrščenimi elementi.
• Ponavljajte, dokler ni razvrščen celoten niz.

Delovanje algoritma za razvrščanje vstavljanja:

Razmislite o nizu, ki ima elemente : {23, 1, 10, 5, 2}

Prvi prehod:

• Trenutni element je 23
• Predpostavlja se, da je prvi element v matriki razvrščen.
• Razvrščeni del do 0 indeks je: [23]

Drugi prehod:

• Primerjaj 1 z 23 (trenutni element z razvrščenim delom).
• Od 1 je manjši, vstavite 1 prej 23 .
• Razvrščeni del do 1 indeks je: [1, 23]

Tretji prehod:

• Primerjaj 10 z 1 in 23 (trenutni element z razvrščenim delom).
• Od 10 je večji od 1 in manjši od 23 , vstavi 10 med 1 in 23 .
• Razvrščeni del do 2 indeks je: [1, 10, 23]

Četrti prehod:

• Primerjaj 5 z 1 , 10 , in 23 (trenutni element z razvrščenim delom).
• Od 5 je večji od 1 in manjši od 10 , vstavi 5 med 1 in 10 .
• Razvrščeni del do 3 indeks je : [1, 5, 10, 23]

Peti prehod:

• Primerjaj 2 z 1, 5, 10 , in 23 (trenutni element z razvrščenim delom).
• Od 2 je večji od 1 in manjši od 5 vstavi 2 med 1 in 5 .
• Razvrščeni del do 4 indeks je: [1, 2, 5, 10, 23]

Končni niz:

• Razvrščen niz je: [1, 2, 5, 10, 23]

Izvedba razvrščanja vstavljanja:

// 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]> ključ) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = ključ;  } } // Pomožna funkcija za tiskanje matrike // velikosti n void printArray(int arr[], int n) { int i;  za (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]> ključ) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = ključ;  } } // Pomožna funkcija za tiskanje matrike velikosti n void printArray(int arr[], int n) { int i;  za (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]> ključ) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = ključ;  } } /* Pomožna funkcija za tiskanje niza velikosti n*/ static void printArray(int arr[]) { int n = arr.length;  za (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 in ključ< 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]> ključ) { arr[j + 1] = arr[j];  j = j - 1;  } arr[j + 1] = ključ;  } } // Pomožna funkcija za tiskanje // matrike velikosti n static void printArray(int[] arr) { int n = arr.Length;  za (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] = $ključ; } } // Pomožna funkcija za // natis matrike velikosti 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>

Časovna zapletenost: O(N^2)
Pomožni prostor: O(1)

Analiza kompleksnosti razvrščanja z vstavljanjem :

Časovna zapletenost razvrščanja vstavljanja

• Najboljši primer: O(n) , Če je seznam že razvrščen, kjer je n število elementov na seznamu.
• Povprečen primer: O(n ² ) , Če je seznam naključno urejen
• V najslabšem primeru: O(n ² ) , Če je seznam v obratnem vrstnem redu

Kompleksnost prostora razvrščanja vstavljanja

• Pomožni prostor: O(1), Razvrščanje vstavljanja zahteva O(1) dodaten prostor, zaradi česar je prostorsko učinkovit algoritem za razvrščanje.

Prednosti vrste vstavljanja:

• Enostavno in enostavno za izvedbo.
• Stabilen algoritem razvrščanja.
• Učinkovito za majhne sezname in skoraj razvrščene sezname.
• Prostorsko učinkovito.

Slabosti vrste vstavljanja:

• Neučinkovito za velike sezname.
• V večini primerov ni tako učinkovit kot drugi algoritmi za razvrščanje (npr. razvrščanje z združevanjem, hitro razvrščanje).

Aplikacije vrste vstavljanja:

Razvrščanje z vstavljanjem se običajno uporablja v primerih, ko:

• Seznam je majhen ali skoraj razvrščen.
• Enostavnost in stabilnost sta pomembni.

Pogosto zastavljena vprašanja o razvrščanju vstavljanja

Q1. Kateri so mejni primeri algoritma za razvrščanje z vstavljanjem?

Razvrščanje z vstavljanjem traja največ časa za razvrščanje, če so elementi razvrščeni v obratnem vrstnem redu. Ko so elementi že razvrščeni, traja minimalni čas (vrstni red n).

Q2. Kaj je algoritemska paradigma algoritma za razvrščanje z vstavljanjem?

Algoritem razvrščanja z vstavljanjem sledi postopnemu pristopu.

Q3. Ali je Insertion Sort algoritem za razvrščanje na mestu?

Da, razvrščanje z vstavljanjem je algoritem za razvrščanje na mestu.

Q4. Ali je razvrščanje z vstavljanjem stabilen algoritem?

Da, razvrščanje z vstavljanjem je stabilen algoritem za razvrščanje.

V5. Kdaj se uporablja algoritem razvrščanja z vstavljanjem?

Razvrščanje z vstavljanjem se uporablja, ko je število elementov majhno. Uporabno je lahko tudi, ko je vhodna matrika skoraj razvrščena in je le nekaj elementov napačno postavljenih v celotno veliko matriko.