Zoradenie vloženia je jednoduchý triediaci algoritmus, ktorý funguje tak, že každý prvok nezoradeného zoznamu sa opakovane vkladá na správnu pozíciu v zoradenej časti zoznamu. Je to a stabilné triedenie algoritmu, čo znamená, že prvky s rovnakými hodnotami si zachovávajú svoje relatívne poradie v triedenom výstupe.

Zoradenie vloženia je ako triediť hracie karty v rukách. Karty rozdelíte do dvoch skupín: roztriedené karty a neroztriedené karty. Potom vyberiete kartu z netriedenej skupiny a vložíte ju na správne miesto v zoradenej skupine.

Algoritmus triedenia vloženia:

Zoradenie vloženia je jednoduchý triediaci algoritmus, ktorý funguje tak, že zostavuje triedené pole jeden prvok po druhom. Považuje sa za na mieste triediaci algoritmus, čo znamená, že nevyžaduje žiadny ďalší pamäťový priestor nad rámec pôvodného poľa.

c# slovník

Algoritmus:

Ak chcete dosiahnuť zoradenie vloženia, postupujte takto:

• Musíme začať s druhým prvkom poľa, pretože sa predpokladá, že prvý prvok v poli je zoradený.
• Porovnajte druhý prvok s prvým prvkom a skontrolujte, či je druhý prvok menší, potom ich vymeňte.
• Presuňte sa na tretí prvok a porovnajte ho s druhým prvkom, potom s prvým prvkom a podľa potreby ho vymeňte, aby ste ho umiestnili na správnu pozíciu medzi prvými tromi prvkami.
• Pokračujte v tomto procese, porovnajte každý prvok s predchádzajúcimi a podľa potreby vymeňte, aby ste ho umiestnili na správnu pozíciu medzi triedenými prvkami.
• Opakujte, kým nie je zoradené celé pole.

Fungovanie algoritmu zoradenia vloženia:

Uvažujme pole s prvkami : {23, 1, 10, 5, 2}

Prvý prechod:

• Aktuálny prvok je 23
• Predpokladá sa, že prvý prvok v poli je zoradený.
• Vytriedená časť až 0 index je: [23]

Druhý prechod:

• Porovnaj 1 s 23 (aktuálny prvok so zoradenou časťou).
• Od r 1 je menšia, vložka 1 predtým 23 .
• Vytriedená časť až 1 index je: [1, 23]

Tretí prechod:

• Porovnaj 10 s 1 a 23 (aktuálny prvok so zoradenou časťou).
• Od r 10 je väčší ako 1 a menšie ako 23 , vložiť 10 medzi 1 a 23 .
• Vytriedená časť až 2 index je: [1, 10, 23]

Štvrtý prechod:

• Porovnaj 5 s 1 , 10 , a 23 (aktuálny prvok so zoradenou časťou).
• Od r 5 je väčší ako 1 a menšie ako 10 , vložiť 5 medzi 1 a 10 .
• Vytriedená časť až 3 index je : [1, 5, 10, 23]

Piaty prechod:

• Porovnaj 2 s 1, 5, 10 , a 23 (aktuálny prvok so zoradenou časťou).
• Od r 2 je väčší ako 1 a menšie ako 5 vložiť 2 medzi 1 a 5 .
• Vytriedená časť až 4 index je: [1, 2, 5, 10, 23]

Konečné pole:

• Zoradené pole je: [1, 2, 5, 10, 23]

Implementácia zoradenia vloženia:

// 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]> kľúč) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = kľúč;  } } // Pomocná funkcia na tlač poľa // veľkosti n void printArray(int arr[], int n) { int i;  pre (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]> kľúč) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = kľúč;  } } // Pomocná funkcia na tlač poľa veľkosti n void printArray(int arr[], int n) { int i;  pre (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]> kľúč) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = kľúč;  } } /* Pomocná funkcia na tlač poľa veľkosti n*/ static void printArray(int arr[]) { int n = arr.length;  pre (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 a kľúč< 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]> kľúč) { arr[j + 1] = arr[j];  j = j-1;  } arr[j + 1] = kľúč;  } } // Pomocná funkcia na tlač // poľa veľkosti n static void printArray(int[] arr) { int n = arr.Length;  pre (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] = $kľúč; } } // Pomocná funkcia na // tlač poľa veľkosti n funkcia 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>

Časová zložitosť: O(N^2)
Pomocný priestor: O(1)

Analýza zložitosti zoradenia vloženia :

Časová zložitosť zoradenia vloženia

• Najlepší prípad: O(n) , Ak je zoznam už zoradený, kde n je počet prvkov v zozname.
• Priemerný prípad: O(n ² ) , Ak je zoznam náhodne usporiadaný
• V najhoršom prípade: O(n ² ) , Ak je zoznam v opačnom poradí

Priestorová zložitosť podľa typu vloženia

• Pomocný priestor: O(1), vyžaduje sa zoradenie vloženia O(1) dodatočný priestor, čo z neho robí priestorovo efektívny triediaci algoritmus.

Výhody podľa typu vloženia:

• Jednoduché a ľahko realizovateľné.
• Stabilný triediaci algoritmus.
• Efektívne pre malé zoznamy a takmer zoradené zoznamy.
• Priestorovo efektívne.

Nevýhody podľa typu vloženia:

• Neefektívne pre veľké zoznamy.
• Vo väčšine prípadov nie sú také efektívne ako iné triediace algoritmy (napr. zlučovacie triedenie, rýchle triedenie).

Aplikácie podľa typu vloženia:

Zoradenie vloženia sa bežne používa v situáciách, keď:

• Zoznam je malý alebo takmer zoradený.
• Dôležitá je jednoduchosť a stabilita.

Často kladené otázky o triedení vkladania

Q1. Aké sú hraničné prípady algoritmu zoradenia vloženia?

reťazec na rozhovor

Triedenie vložením zaberie zoradenie maximálny čas, ak sú prvky zoradené v opačnom poradí. A trvá to minimálny čas (poradie n), keď sú prvky už zoradené.

Q2. Čo je to algoritmická paradigma algoritmu triedenia vloženia?

znak na int v jazyku Java

Algoritmus triedenia vloženia sleduje inkrementálny prístup.

Q3. Je triedenie vložením triediaci algoritmus na mieste?

Áno, triedenie vložením je algoritmus triedenia na mieste.

Q4. Je triedenie vkladania stabilným algoritmom?

Áno, triedenie vkladania je stabilný algoritmus triedenia.

Q5. Kedy sa používa algoritmus zoradenia vloženia?

Triedenie vloženia sa používa, keď je počet prvkov malý. Môže to byť užitočné aj vtedy, keď je vstupné pole takmer zoradené a v kompletnom veľkom poli je nesprávne umiestnených len niekoľko prvkov.