Binārā ievietošanas kārtošana ir šķirošanas algoritms, kas ir līdzīgs ievietošanas kārtošana , bet tā vietā, lai izmantotu lineāro meklēšanu, lai atrastu vietu, kur jāievieto elements, mēs izmantojam binārā meklēšana . Tādējādi mēs samazinām viena elementa ievietošanas salīdzinošo vērtību no O (N) uz O (log N).
Tas ir elastīgs algoritms, kas nozīmē, ka tas darbojas ātrāk, ja vieni un tie paši dalībnieki jau ir ļoti sakārtoti, t.i., objekta pašreizējā atrašanās vieta ir tuvāk tās faktiskajai atrašanās vietai sakārtotajā sarakstā.
Tas ir stabils filtrēšanas algoritms – elementi ar vienādām vērtībām parādās tādā pašā secībā pēdējā secībā, kādā tie bija pirmajā sarakstā.
Binārās ievietošanas kārtošanas lietojumprogrammas:
- Binārās ievietošanas kārtošana vislabāk darbojas, ja masīvā ir mazāks vienumu skaits.
- Veicot ātro kārtošanu vai sapludināšanas kārtošanu, kad apakšgrupas izmērs kļūst mazāks (piemēram, <= 25 elementi), vislabāk ir izmantot bināro ievietošanas kārtošanu.
- Šis algoritms darbojas arī tad, ja atslēgu salīdzināšanas izmaksas ir pietiekami augstas. Piemēram, ja vēlamies filtrēt vairākas virknes, divu virkņu salīdzināšanas veiktspēja būs augstāka.
Kā darbojas binārā ievietošanas kārtošana?
- Binārās ievietošanas kārtošanas režīmā vienus un tos pašus dalībniekus sadalām divos apakšblokos – filtrētajā un nefiltrētajā. To pašu dalībnieku pirmais elements atrodas organizētajā apakšgrupā, un visi pārējie elementi ir neplānoti.
- Pēc tam mēs atkārtojam no otrā elementa līdz pēdējam. Atkārtojot i-to, mēs pašreizējo objektu padarām par mūsu atslēgu. Šī atslēga ir funkcija, kas mums jāpievieno esošajam sarakstam.
- Lai to izdarītu, mēs vispirms izmantojam bināro meklēšanu tālāk esošajā sakārtotajā apakšgrupā, lai atrastu tāda elementa atrašanās vietu, kas ir lielāks par mūsu atslēgu. Sauksim šo pozīciju par poz. Pēc tam mēs pa labi nobīdām visus elementus no poz uz 1 un izveidojām Array [pos] = taustiņu.
- Var atzīmēt, ka katrā i-tajā reizinājumā masīva kreisā daļa līdz (i – 1) jau ir sakārtota.
Pieeja binārās ievietošanas kārtošanas ieviešanai:
- Atkārtojiet masīvu no otrā elementa līdz pēdējam elementam.
- Saglabājiet pašreizējo elementu A[i] mainīgā atslēgā.
- Izmantojot bināro meklēšanu, atrodiet elementa pozīciju, kas ir nedaudz lielāka par A[i] apakšmasīvā no A[0] līdz A[i-1]. Pieņemsim, ka šis elements atrodas indeksa pozīcijā.
- Pārvietojiet visus elementus no indeksa poz uz i-1 pa labi.
- A[pos] = atslēga.
Tālāk ir norādīta iepriekš minētās pieejas īstenošana.
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[zems]) ?> >(low + 1) : low;> >int> mid = (low + high) / 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);> }> // 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] = atlasīts; } } // Draivera kods int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n =(a) lielums /(a[0] lielums), i; insertionSort(a, n); cout<<'Sorted array:
'; for (i = 0; i cout <<' '<< a[i]; return 0; } // this code is contribution by shivanisinghss2110> |
>
>
C
masīvu saraksts java
// 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[zems]) ?>> >int> mid = (low + high) / 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);> }> // 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] = atlasīts; } } // Draivera kods int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n =(a) lielums /(a[0] lielums), i; insertionSort(a, n); printf('Kārtots masīvs:
'); for (i = 0; i printf('%d ', a[i]); return 0; }> |
>
>
Java
// 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]>val:> >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>beigas:> >return> start> >mid>=> (start>+>end)>/>/>2> >if> arr[mid] return binary_search(arr, val, mid+1, end) elif arr[mid]>val: return binary_search(arr, val, start, mid-1) else: return mid def insertion_sort(arr): for i diapazonā(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('Sorted array:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Mohits Gupta_OMG > |
>
>
C#
0,04 kā daļu
// 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[$low]) ? ($zems + 1) : $zems; $vidus = (int)(($zems + $augsts) / 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); } // Funkcija a izmēra masīva kārtošanai 'n' function insertionSort(&$a, $n) { $i; $loc; $j; $k; $selected; par ($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] = $atlasīts; } } // Draivera kods $a = masīvs(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54); $n = izmērs($a); insertionSort($a, $n); echo 'Sakārtots masīvs:
'; priekš ($i = 0; $i<$n; $i++) echo '$a[$i] '; // This code is contributed by // Adesh Singh ?>>> |
>
>// Javascript Program implementing>// binary insertion sort>function>binarySearch(a, item, low, high)>{>>>if>(high <= low)>>return>(item>a[zems]) ?>>(low + 1) : low;>>>mid = Math.floor((low + high) / 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);>}>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) {masīvs[j + 1] = masīvs[j]; j--; } // Elementa novietošana tā // pareizajā atrašanās vietas masīvā[j+1] = x; } } // Draivera kods let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; šķirot(arr); for (let i = 0; i document.write(arr[i] + ' '); // Šo kodu nodrošina unknown2108 // C programma, lai īstenotu // binārās ievietošanas kārtošana #include // Binārā meklēšana balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int a[low..high] int binarySearch(int a[], int item, int low, int high) { if (high)<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītais jāievieto loc = binarySearch(a, atlasīts, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i]); r// C programma // binārā ievietošanas kārtošanai #include // Uz bināro meklēšanu balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int binarySearch(int a[], int item, int low, int high) { ja (augsts<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītā vieta ir jāievieto. loc = binarySearch(a, selected, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i]); // C programma // binārā ievietošanas kārtošanas # ieviešanai iekļaut // Bināro meklēšanu balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int binarySearch(int a[], int item, int low, int high) { if (augsts<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītā vieta ir jāievieto. loc = binarySearch(a, selected, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i]); // C programma // binārā ievietošanas kārtošanas # ieviešanai iekļaut // Bināro meklēšanu balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int binarySearch(int a[], int item, int low, int high) { if (augsts<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītais jāievieto loc = binarySearch(a, atlasīts, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i]); // C programma // binārā ievietošanas kārtošanas # ieviešanai iekļaut // Bināro meklēšanu balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int binarySearch(int a[], int item, int low, int high) { if (augsts<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītā vieta ir jāievieto. loc = binarySearch(a, selected, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i]);// C programma // binārā ievietošanas kārtošanas # ieviešanai iekļaut // Bināro meklēšanu balstīta funkcija // lai atrastu pozīciju // kur vienums jāievieto // int binarySearch(int a[], int item, int low, int high) { if (augsts<= low) return (item>a[zems]) ? (zems + 1) : zems; int mid = (zems + augsts) / 2; if (prece == a[mid]) return mid + 1; if (item> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, prece, low, mid - 1); } // Funkcija, lai kārtotu masīvu a[] ar izmēru 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; atlasīts = a[i]; // atrast vietu, kur atlasītā vieta ir jāievieto. loc = binarySearch(a, selected, 0, j); // Pārvietot visus elementus pēc atrašanās vietas lai izveidotu atstarpi, kamēr (j>= loc) { a[j + 1] = a[j] } a[j + 1] = atlasīts } } // Draivera kods int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int = izmērs(a) / izmērs(a[0]), i; ); printf('Sakārtots masīvs: '); for (i = 0; i printf('%d ', a[i])>>>IzvadeSorted array: 0 12 17 23 31 37 46 54 72 88 100>Laika sarežģītība: Algoritmam kopumā joprojām ir sliktākā gadījuma darbības laiks O (n2), jo katrai ievietošanai ir nepieciešamas mijmaiņas darījumu sērijas.
Cita pieeja: Tālāk ir sniegta iepriekš minētā rekursīvā koda iteratīva ieviešana
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[mid])>>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] = atlasīts; } } // Draivera kods int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n =(a) lielums /(a[0] lielums), i; insertionSort(a, n); cout<<'Sorted array: '; for (i = 0; i cout <<' '<< a[i]; return 0; } // This code is contributed by shivanisinghss2110.>>>C
izveidot savienojumu ar datubāzi java
#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[mid])>>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] = atlasīts; } } // Draivera kods int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n =(a) lielums /(a[0] lielums), i; insertionSort(a, n); printf('Kārtots masīvs: '); for (i = 0; i printf('%d ', a[i]); atgriež 0; } // pievienoja tmeid>>>Java
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[mid])>>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] = atlasīts; } } // Draivera koda publiskais statiskais void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.garums, i; insertionSort(a, n); System.out.println('Kārtots masīvs:'); for (i = 0; i System.out.print(a[i] +' '); } } // Šo kodu ir sagatavojis 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[mid])>>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] = atlasīts; } } // Draivera kods public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a. Garums, i; insertionSort(a, n); Console.WriteLine('Kārtots masīvs:'); for (i = 0; i Console.Write(a[i] +' '); } } // Šo kodu ir sagatavojis shivanisinghss2110>mācīties selēnu>>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[mid])>>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] = atlasīts; } } // Draivera kods var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ]; var n = a.garums, i; insertionSort(a, n); document.write('Sakārtots masīvs:' + ' '); for (i = 0; i document.write(a[i] +' '); // Šo kodu ir nodrošinājis shivanisinghss2110>>>IzvadeSorted array: 0 12 17 23 31 37 46 54 72 88 100>