BINARNE SORTOWANIE PRZEZ WSTAWIANIE - TECHCODEVIEW.COM - ALGORYTMY

Binarne sortowanie przez wstawianie to algorytm sortowania podobny do sortowanie przez wstawianie , ale zamiast korzystać z wyszukiwania liniowego, aby znaleźć miejsce, w którym należy wstawić element, używamy wyszukiwanie binarne . W ten sposób zmniejszamy wartość porównawczą wstawienia pojedynczego elementu z O (N) do O (log N).

Jest to algorytm elastyczny, co oznacza, że działa szybciej, gdy te same elementy są już mocno posortowane, czyli bieżąca lokalizacja obiektu jest bliższa jej rzeczywistej lokalizacji na posortowanej liście.

Jest to stabilny algorytm filtrowania – elementy o tych samych wartościach pojawiają się w tej samej kolejności w ostatniej kolejności, co na pierwszej liście.

Zastosowania sortowania binarnego:

Binarne sortowanie przez wstawianie działa najlepiej, gdy tablica ma mniejszą liczbę elementów.
Podczas sortowania szybkiego lub sortowania przez scalanie, gdy rozmiar podtablicy staje się mniejszy (powiedzmy <= 25 elementów), najlepiej zastosować binarne sortowanie przez wstawianie.
Algorytm ten działa również wtedy, gdy koszt porównań pomiędzy kluczami jest wystarczająco wysoki. Na przykład, jeśli chcemy odfiltrować wiele ciągów, wydajność porównania dwóch ciągów będzie wyższa.

Jak działa binarne sortowanie przez wstawianie?

W binarnym trybie sortowania przez wstawianie te same elementy dzielimy na dwie podtablice – filtrowaną i niefiltrowaną. Pierwszy element tych samych elementów znajduje się w zorganizowanej podtablicy, a wszystkie pozostałe elementy są nieplanowane.
Następnie iterujemy od drugiego elementu do ostatniego. Powtarzając i-te, bieżący obiekt staje się naszym kluczem. Ten klucz to funkcja, którą powinniśmy dodać do naszej istniejącej listy poniżej.
Aby to zrobić, najpierw używamy wyszukiwania binarnego w posortowanej podtablicy poniżej, aby znaleźć lokalizację elementu większego niż nasz klucz. Nazwijmy to stanowisko poz. Następnie przesuwamy wszystkie elementy w prawo z pozycji na 1 i tworzymy Array[pos] = key.
Możemy zauważyć, że w każdym i-tym mnożeniu lewa część tablicy aż (i – 1) jest już posortowana.

Podejście do implementacji sortowania przez wstawianie binarne:

Iteruj tablicę od drugiego elementu do ostatniego elementu.
Zapisz bieżący element A[i] w kluczu zmiennym.
Znajdź położenie elementu nieco większego niż A[i] w podtablicy od A[0] do A[i-1], korzystając z wyszukiwania binarnego. Powiedzmy, że ten element znajduje się w pozycji indeksu.
Przesuń wszystkie elementy z pozycji indeksowej do i-1 w prawo.
A[pos] = klucz.

Poniżej implementacja powyższego podejścia:

C++

// C program for implementation of> // binary insertion sort> #include> using> namespace> std;> // A binary search based function> // to find the position> // where item should be inserted> // in a[low..high]> int> binarySearch(>int> a[],>int> item,> >int> low,>int> high)> {> >if> (high <= low)> >return> (item>a[niski]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[środek])> >return> binarySearch(a, item,> >mid + 1, high);> >return> binarySearch(a, item, low,> >mid - 1);> }> // Function to sort an array a[] of size 'n'> void> insertionSort(>int> a[],>int> n)> {> >int> i, loc, j, k, selected;> >for>

(i = 1; i   {  j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = rozmiar(a) / rozmiar(a[0]), i;  sortowanie wstawiania(a, n);  cout<<'Sorted array: 
';  for (i = 0; i   cout <<' '<< a[i];  return 0; } // this code is contribution by shivanisinghss2110>

C

// C program for implementation of> // binary insertion sort> #include> // A binary search based function> // to find the position> // where item should be inserted> // in a[low..high]> int> binarySearch(>int> a[],>int> item,> >int> low,>int> high)> {> >if> (high <= low)> >return> (item>a[niski])?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[środek])> >return> binarySearch(a, item,> >mid + 1, high);> >return> binarySearch(a, item, low,> >mid - 1);> }> // Function to sort an array a[] of size 'n'> void> insertionSort(>int> a[],>int> n)> {> >int> i, loc, j, k, selected;> >for>

(i = 1; i   {  j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = rozmiar(a) / rozmiar(a[0]), i;  sortowanie wstawiania(a, n);  printf('Posortowana tablica: 
');  for (i = 0; i printf('%d ', a[i]); return 0; }>

Jawa

0,2 jako ułamek

pobierz filmy z YouTube'a na VLC

// Java Program implementing> // binary insertion sort> import> java.util.Arrays;> class> GFG> {> > >public> static> void> main(String[] args)> >{> >final> int>[] arr = {>37>,>23>,>0>,>17>,>12>,>72>,> >31>,>46>,>100>,>88>,>54> };> >new> GFG().sort(arr);> >for> (>int> i =>0>

; i   System.out.print(arr[i] + ' ');  }  // Driver Code  public void sort(int array[])  {  for (int i = 1; i   {  int x = array[i];  // Find location to insert  // using binary search  int j = Math.abs(  Arrays.binarySearch(array, 0,   i, x) + 1);  // Shifting array to one  // location right  System.arraycopy(array, j,  array, j + 1, i - j);  // Placing element at its   // correct location  array[j] = x;  }  } } // Code contributed by Mohit Gupta_OMG>

Python3

# Python Program implementation> # of binary insertion sort> def> binary_search(arr, val, start, end):> > ># we need to distinguish whether we> ># should insert before or after the> ># left boundary. imagine [0] is the last> ># step of the binary search and we need> ># to decide where to insert -1> >if> start>=>=> end:> >if> arr[start]>wartość:> >return> start> >else>:> >return> start>+>1> ># this occurs if we are moving> ># beyond left's boundary meaning> ># the left boundary is the least> ># position to find a number greater than val> >if> start>koniec:> >return> start> >mid>=> (start>+>end)>/>/>2> >if>

arr[mid]   return binary_search(arr, val, mid+1, end)  elif arr[mid]>val: zwróć binary_search(arr, val, start, mid-1) else: zwróć środkową def wstawianie_sort(arr): dla i w zakresie(1, len(arr)): val = arr[i] j = binary_search(arr, val, 0, i-1) arr = arr[:j] + [val] + arr[j:i] + arr[i+1:] return arr print('Sortowana tablica:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Kod nadesłany przez Mohita Guptę_OMG>

C#

// C# Program implementing> // binary insertion sort> using> System;> class> GFG {> >public> static> void> Main()> >{> >int>[] arr = { 37, 23, 0, 17, 12, 72,> >31, 46, 100, 88, 54 };> >sort(arr);> >for> (>int>

i = 0; i   Console.Write(arr[i] + ' ');  }  // Driver Code  public static void sort(int[] array)  {  for (int i = 1; i   {  int x = array[i];  // Find location to insert using  // binary search  int j = Math.Abs(  Array.BinarySearch(array,   0, i, x) + 1);  // Shifting array to one location right  System.Array.Copy(array, j,   array, j + 1,  i - j);  // Placing element at its correct  // location  array[j] = x;  }  } } // This code is contributed by nitin mittal.>

PHP

 // PHP program for implementation of  // binary insertion sort // A binary search based function to find  // the position where item should be  // inserted in a[low..high] function binarySearch($a, $item, $low, $high) {  if ($high <= $low)   return ($item>$a[$niski])?   ($niski + 1): $niski;   $mid = (int)(($niski + $wysoki) / 2);   if($item == $a[$mid]) return $mid + 1;   if($item> $a[$mid]) return binarySearch($a, $item, $mid + 1, $high);     return binarySearch($a, $item, $low, $mid - 1);  } // Funkcja sortowania tablicy a o rozmiarze 'n' funkcja wstawianiaSort(&$a, $n) { $i; $lok; $j; $ tys.; $wybrane;   dla ($i = 1; $i<$n; ++$i)   {   $j = $i - 1;   $selected = $a[$i];   // find location where selected   // item should be inserted   $loc = binarySearch($a, $selected, 0, $j);   // Move all elements after location   // to create space   while ($j>= $loc) { $a[$j + 1] = $a[$j];   $j--;   } $a[$j + 1] = $wybrane;   } } // Kod sterownika $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54);    $n = rozmiar($a);  sortowanie wstawiania($a, $n);  echo 'Posortowana tablica:
';  dla ($i = 0; $i<$n; $i++)   echo '$a[$i] ';  // This code is contributed by  // Adesh Singh ?>>

JavaScript

> // Javascript Program implementing> // binary insertion sort> function> binarySearch(a, item, low, high)> {> > >if> (high <= low)> >return> (item>a[niski]) ?> >(low + 1) : low;> > >mid = Math.floor((low + high) / 2);> > >if>(item == a[mid])> >return> mid + 1;> > >if>(item>a[środek])> >return> binarySearch(a, item,> >mid + 1, high);> > >return> binarySearch(a, item, low,> >mid - 1);> }> function> sort(array)> {> >for>

(let i = 1; i   {  let j = i - 1;  let x = array[i];    // Find location to insert  // using binary search  let loc = Math.abs(  binarySearch(array, x,  0, j));    // Shifting array to one  // location right    while (j>= loc) { tablica[j + 1] = tablica[j];  J--;  } // Umieszczenie elementu w jego // poprawnej lokalizacji array[j+1] = x;  } } // Kod sterownika let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; sortuj(arr); for (let i = 0; i document.write(arr[i] + ' '); // Ten kod został napisany przez nieznany2108 // Program w C służący do implementacji // binarnego sortowania przez wstawianie #include // Wyszukiwanie binarne funkcja oparta // aby znaleźć pozycję // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { if (high<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której należy wstawić wybrane loc = binarySearch(a, wybrane, 0, j); // Przesuń wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Sortowana tablica: 
'); for (i = 0; i printf('%d ', a[i]); r// Program C do implementacji // binarnego sortowania przez wstawianie #include // Funkcja oparta na wyszukiwaniu binarnym // pozwalająca znaleźć pozycję // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { jeśli (wysoki<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której wybrane powinno zostać wstawione loc = binarySearch(a, wybrane, 0, j); // Przenieś wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Sortowana tablica: 
'); for (i = 0; i printf('%d ', a[i]); // Program C do implementacji // binarnego sortowania przez wstawianie include // Funkcja oparta na wyszukiwaniu binarnym // w celu znalezienia pozycji // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { if (wysoki<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której wybrane powinno zostać wstawione loc = binarySearch(a, wybrane, 0, j); // Przesuń wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Sortowana tablica: 
'); for (i = 0; i printf('%d ', a[i]); // Program w C do implementacji // binarnego sortowania przez wstawianie include // Funkcja oparta na wyszukiwaniu binarnym // w celu znalezienia pozycji // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { if (wysoki<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której należy wstawić wybrane loc = binarySearch(a, wybrane, 0, j); // Przesuń wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Sortowana tablica: 
'); for (i = 0; i printf('%d ', a[i]); // Program w C do implementacji // binarnego sortowania przez wstawianie include // Funkcja oparta na wyszukiwaniu binarnym // w celu znalezienia pozycji // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { if (wysoki<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której wybrane powinno zostać wstawione loc = binarySearch(a, wybrane, 0, j); // Przesuń wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Sortowana tablica: 
'); for (i = 0; i printf('%d ', a[i]);// Program C do implementacji // binarnego sortowania przez wstawianie include // Funkcja oparta na wyszukiwaniu binarnym // w celu znalezienia pozycji // gdzie element powinien zostać wstawiony // w a[low..high] int binarySearch(int a[], int item, int low, int high) { if (wysoki<= low)  return (item>a[niski])?  (niski + 1): niski;  int mid = (niski + wysoki) / 2;  if (item == a[mid]) return mid + 1;  if (element> a[mid]) return binarySearch(a, item, mid + 1, high);  return binarySearch(a, pozycja, niska, średnia - 1); } // Funkcja sortująca tablicę a[] o rozmiarze 'n' void wstawiaSort(int a[], int n) { int i, loc, j, k, wybrane;  for (i = 1; i { j = i - 1; wybrane = a[i]; // znajdź lokalizację, w której wybrane powinno zostać wstawione loc = binarySearch(a, wybrane, 0, j); // Przesuń wszystkie elementy po lokalizacji utworzyć spację while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = wybrane; } } // Kod sterownika int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = rozmiar(a) / rozmiar(a[0]), i; ); printf('Posortowana tablica: 
'); for (i = 0; i printf('%d ', a[i])>

Wyjście

wielopostaciowość

Sorted array: 0 12 17 23 31 37 46 54 72 88 100>

Złożoność czasowa: Algorytm jako całość nadal ma najgorszy czas działania wynoszący O(n²) ze względu na serię wymian wymaganych dla każdego wstawienia.

Inne podejście: Poniżej znajduje się iteracyjna implementacja powyższego kodu rekurencyjnego

C++

#include> using> namespace> std;> // iterative implementation> int> binarySearch(>int> a[],>int> item,>int> low,>int> high)> {> >while> (low <= high) {> >int> mid = low + (high - low) / 2;> >if> (item == a[mid])> >return> mid + 1;> >else> if> (item>a[środek])> >low = mid + 1;> >else> >high = mid - 1;> >}> >return> low;> }> // Function to sort an array a[] of size 'n'> void> insertionSort(>int> a[],>int> n)> {> >int> i, loc, j, k, selected;> >for>

(i = 1; i   j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = rozmiar(a) / rozmiar(a[0]), i;  sortowanie wstawiania(a, n);  cout<<'Sorted array: 
';  for (i = 0; i   cout <<' '<< a[i];  return 0; } // This code is contributed by shivanisinghss2110.>

C

#include> // iterative implementation> int> binarySearch(>int> a[],>int> item,>int> low,>int> high)> {> >while> (low <= high) {> >int> mid = low + (high - low) / 2;> >if> (item == a[mid])> >return> mid + 1;> >else> if> (item>a[środek])> >low = mid + 1;> >else> >high = mid - 1;> >}> >return> low;> }> // Function to sort an array a[] of size 'n'> void> insertionSort(>int> a[],>int> n)> {> >int> i, loc, j, k, selected;> >for>

(i = 1; i   j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = rozmiar(a) / rozmiar(a[0]), i;  sortowanie wstawiania(a, n);  printf('Posortowana tablica: 
');  for (i = 0; i printf('%d ', a[i]); return 0; } // wniesiony przez tmeid>

przykłady automatów dfa

Jawa

import> java.io.*;> class> GFG {> // iterative implementation> static> int> binarySearch(>int> a[],>int> item,>int> low,>int> high)> {> >while> (low <= high) {> >int> mid = low + (high - low) />2>;> >if> (item == a[mid])> >return> mid +>1>;> >else> if> (item>a[środek])> >low = mid +>1>;> >else> >high = mid ->1>;> >}> >return> low;> }> // Function to sort an array a[] of size 'n'> static> void> insertionSort(>int> a[],>int> n)> {> >int> i, loc, j, k, selected;> >for> (i =>1>

; i   j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika public static void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = a.length, i;  sortowanie wstawiania(a, n);  System.out.println('Posortowana tablica:');  for (i = 0; i System.out.print(a[i] +' '); } } // Ten kod jest dziełem Shivanisinghss2110.>

Python3

# iterative implementation> def> binarySearch(a, item, low, high):> >while> (low <>=> high):> >mid>=> low>+> (high>-> low)>/>/> 2> >if> (item>=>=> a[mid]):> >return> mid>+> 1> >elif> (item>a[mid]):> >low>=> mid>+> 1> >else>:> >high>=> mid>-> 1> >return> low> > # Function to sort an array a[] of size 'n'> def> insertionSort(a, n):> >for> i>in> range> (n):> >j>=> i>-> 1> >selected>=> a[i]> > ># find location where selected should be inserted> >loc>=> binarySearch(a, selected,>0>, j)> > ># Move all elements after location to create space> >while> (j>>=> loc):> >a[j>+> 1>]>=> a[j]> >j>->=>1> >a[j>+> 1>]>=> selected> # Driver Code> a>=> [>37>,>23>,>0>,>17>,>12>,>72>,>31>,>46>,>100>,>88>,>54>]> n>=> len>(a)> insertionSort(a, n)> print>(>'Sorted array: '>)> for> i>in> range> (n):> >print>(a[i], end>=>' '>)> # This code is contributed by shivanisinghss2110>

C#

using> System;> class> GFG {> // iterative implementation> static> int> binarySearch(>int> []a,>int> item,>int> low,>int> high)> {> >while> (low <= high) {> >int> mid = low + (high - low) / 2;> >if> (item == a[mid])> >return> mid + 1;> >else> if> (item>a[środek])> >low = mid + 1;> >else> >high = mid - 1;> >}> >return> low;> }> // Function to sort an array a[] of size 'n'> static> void> insertionSort(>int> []a,>int> n)> {> >int> i, loc, j, selected;> >for>

(i = 1; i   j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = a.Długość, i;  sortowanie wstawiania(a, n);  Console.WriteLine('Sortowana tablica:');  for (i = 0; i Console.Write(a[i] +' '); } } // Ten kod został napisany przez shivanisinghss2110>

string.format w Javie

JavaScript

> // iterative implementation> function> binarySearch( a, item, low, high)> {> >while> (low <= high) {> >var> mid = low + (high - low) / 2;> >if> (item == a[mid])> >return> mid + 1;> >else> if> (item>a[środek])> >low = mid + 1;> >else> >high = mid - 1;> >}> >return> low;> }> // Function to sort an array a[] of size 'n'> function> insertionSort(a, n)> {> >var> i, loc, j, k, selected;> >for>

(i = 1; i   j = i - 1;  selected = a[i];  // find location where selected should be inserted  loc = binarySearch(a, selected, 0, j);  // Move all elements after location to create space  while (j>= loc) { a[j + 1] = a[j];  J--;  } a[j + 1] = wybrane;  } } // Kod sterownika var a = [37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ];  var n = a.długość, i;  sortowanie wstawiania(a, n);  document.write('Posortowana tablica:' + ' ');  for (i = 0; i document.write(a[i] +' '); // Ten kod został napisany przez Shivanisinghss2110>

Wyjście

Sorted array: 0 12 17 23 31 37 46 54 72 88 100>