logo

TechCodeview

Ordenació d'inserció binària

L'ordenació per inserció binària és un algorisme d'ordenació similar al ordenació d'inserció , però en comptes d'utilitzar la cerca lineal per trobar la ubicació on s'ha d'inserir un element, fem servir cerca binària . Així, reduïm el valor comparatiu d'inserir un sol element de O (N) a O (log N).

És un algorisme flexible, el que significa que funciona més ràpidament quan els mateixos membres ja estan molt ordenats, és a dir, la ubicació actual de la funció està més a prop de la seva ubicació real a la llista ordenada.



És un algorisme de filtrat estable: els elements amb els mateixos valors apareixen en la mateixa seqüència en l'últim ordre que a la primera llista.

Aplicacions de l'ordenació d'inserció binària:

  • L'ordenació per inserció binària funciona millor quan la matriu té un nombre menor d'elements.
  • Quan feu una ordenació ràpida o una ordenació per fusió, quan la mida del subbarray es fa més petita (per exemple, <= 25 elements), el millor és utilitzar una ordenació d'inserció binària.
  • Aquest algorisme també funciona quan el cost de les comparacions entre claus és prou alt. Per exemple, si volem filtrar diverses cadenes, el rendiment de comparació de dues cadenes serà més gran.

Com funciona l'ordenació d'inserció binària?

  • En el mode d'ordenació d'inserció binària, dividim els mateixos membres en dos subbarrays: filtrats i no filtrats. El primer element dels mateixos membres es troba al subarranjament organitzat i tots els altres elements no són planificats.
  • A continuació, iterem des del segon element fins a l'últim. En la repetició de la i-èsima, fem de l'objecte actual la nostra clau. Aquesta clau és una característica que hauríem d'afegir a la nostra llista existent a continuació.
  • Per fer-ho, primer utilitzem una cerca binària al subbarrat ordenat a continuació per trobar la ubicació d'un element més gran que la nostra clau. Anomenem aquesta posició pos. A continuació, canviem a la dreta tots els elements de pos a 1 i hem creat Array[pos] = key.
  • Podem observar que en cada multiplicació i-èsima, la part esquerra de la matriu fins (i – 1) ja està ordenada.

Enfocament per implementar l'ordenació d'inserció binària:

  • Itera la matriu des del segon element fins a l'últim element.
  • Emmagatzema l'element actual A[i] en una clau variable.
  • Trobeu la posició de l'element només més gran que A[i] a la subbarra de A[0] a A[i-1] mitjançant la cerca binària. Diguem que aquest element es troba a l'índex pos.
  • Desplaceu tots els elements de l'índex pos a i-1 cap a la dreta.
  • A[pos] = clau.

A continuació es mostra la implementació de l'enfocament anterior:

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[baix]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mitjana])> >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] = seleccionat; } } // Codi del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = grandària de (a) / grandària de (a[0]), i; insercióOrdenar(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[baix])?>>> (low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mitjana])> >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] = seleccionat; } } // Codi del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = grandària de (a) / grandària de (a[0]), i; insercióOrdenar(a, n); printf('Matriu ordenada: '); per (i = 0; i printf('%d', a[i]); retorna 0; }>

mètode tostring java 

>

>

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> 

>

>

Python 3




# 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>final:> >return> start> >mid>=> (start>+>end)>/>/>2> >if> arr[mid] return binary_search(arr, val, mid+1, end) elif arr[mid]>val: retorna binary_search(arr, val, start, mid-1) else: retorna mid def insertion_sort(arr): per a i dins el rang (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('Matriu ordenada:') print(inserció_ordenar( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Codi aportat per Mohit Gupta_OMG>>> 

> 
    
   
 
     
  
 
    
 
     
     
    
Com obtenir el joc Pigeon a Android

 
 
  
  // 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])?   ($baix + 1): $baix;   $mid = (int)(($baix + $alt) / 2);   if($element == $a[$mit]) retorna $mit + 1;   if($item> $a[$mit]) retorna binarySearch($a, $item, $mit + 1, $high);     return binarySearch($a, $element, $baix, $mitjana - 1);  } // Funció per ordenar una matriu a de mida 'n' function insertionSort(&$a, $n) { $i; $loc; $j; $k; $seleccionat;   per ($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] = $seleccionat;   } } // Codi del controlador $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54);    $n = grandària de ($a);  insercióOrdenar($a, $n);  echo 'Matriu ordenada:
';  per ($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[baix]) ?> >(low + 1) : low;> > >mid = Math.floor((low + high) / 2);> > >if>(item == a[mid])> >return> mid + 1;> > >if>(item>a[mitjana])> >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) { array[j + 1] = array[j];  j--;  } // Col·locant l'element a la seva // matriu de ubicació correcta[j+1] = x;  } } // Codi del controlador let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; ordenar (arr); for (let i = 0; i document.write(arr[i] + ' '); // Aquest codi és aportat per unknown2108 // programa C per a la implementació de // binary insertion sort #include // Una cerca binària funció basada // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int element, int low, int high) { if (high)<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // cerca la ubicació on s'ha d'inserir la selecció loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i]); r// programa C per a la implementació de // inserció binària #include // Una funció basada en la cerca binària // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int element, int low, int high) { si (alt<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // Troba la ubicació on s'ha d'inserir seleccionada loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i]); // Programa C per a la implementació de // inserció binària # include // Una funció basada en la cerca binària // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int item, int low, int high) { if (alt<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // Troba la ubicació on s'ha d'inserir seleccionada loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i]); // Programa C per a la implementació de // inserció binària # include // Una funció basada en la cerca binària // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int item, int low, int high) { if (alt<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // cerca la ubicació on s'ha d'inserir la selecció loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i]); // Programa C per a la implementació de // inserció binària # include // Una funció basada en la cerca binària // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int item, int low, int high) { if (alt<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // Troba la ubicació on s'ha d'inserir seleccionada loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i]);// Programa C per a la implementació de // inserció binària # include // Una funció basada en la cerca binària // per trobar la posició // on s'ha d'inserir l'element // en a[low..high] int binarySearch(int a[], int item, int low, int high) { if (alt<= low)  return (item>a[baix])?  (baix + 1): baix;  int mid = (baix + alt) / 2;  if (element == a[mit]) retorna mig + 1;  if (item> a[mit]) retorna binarySearch(a, item, mid + 1, high);  return binarySearch (a, element, baix, mitjà - 1); } // Funció per ordenar una matriu a[] de mida 'n' void insertionSort(int a[], int n) { int i, loc, j, k, seleccionada;  for (i = 1; i { j = i - 1; seleccionat = a[i]; // Troba la ubicació on s'ha d'inserir seleccionada loc = binarySearch(a, selected, 0, j); // Mou tots els elements després de la ubicació crear espai mentre (j>= loc) { a[j + 1] = a[j] } a[j + 1] = seleccionat } } // Codi del controlador int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 } int n = sizeof(a) / sizeof(a[0]), i inserció(a, n ); printf('Matriu ordenat: 
'); per (i = 0; i printf('%d ', a[i])> 
  
 
    
 
>
 
    
què és svn checkout

 
>
 
  Sortida  
 
Sorted array: 0 12 17 23 31 37 46 54 72 88 100>
 
  Complexitat temporal: L'algorisme en conjunt encara té un temps d'execució en el pitjor dels casos de O (n2) a causa de la sèrie d'intercanvis necessaris per a cada inserció.
 
  Un altre enfocament: A continuació es mostra una implementació iterativa del codi recursiu anterior
 
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[mitjana])> >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] = seleccionat;  } } // Codi del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = grandària de (a) / grandària de (a[0]), i;  insercióOrdenar(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[mitjana])> >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] = seleccionat;  } } // Codi del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = grandària de (a) / grandària de (a[0]), i;  insercióOrdenar(a, n);  printf('Matriu ordenada: 
');  per (i = 0; i printf('%d ', a[i]); retorn 0; } // aportat per 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[mitjana])> >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] = seleccionat;  } } // Codi del controlador public static void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = a.longitud, i;  insercióOrdenar(a, n);  System.out.println('Matriu ordenada:');  for (i = 0; i System.out.print(a[i] +' '); } } // Aquest codi és aportat per shivanisinghss2110.> 
  
 
    
 
>
 
    
 
>
 
 
Python 3
    
 
     
  
 
    
 
     
     
    
 
 
  
  # 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[mitjana]):> >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[mitjana])> >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] = seleccionat;  } } // Codi del controlador public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 };  int n = a.Longitud, i;  insercióOrdenar(a, n);  Console.WriteLine('Matriu ordenada:');  for (i = 0; i Console.Write(a[i] +' '); } } // Aquest codi és aportat per shivanisinghss2110>>> 
  
 
    
 
> 
    
   
com convertir una cadena a enter

 
     
  
 
    
 
     
     
    
 
 
  
  > // 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[mitjana])> >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] = seleccionat;  } } // Codi del conductor var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ];  var n = a.longitud, i;  insercióOrdenar(a, n);  document.write('Matriu ordenada:' + ' ');  for (i = 0; i document.write(a[i] +' '); // Aquest codi és aportat per shivanisinghss2110>>> 
  
 
    
 
> 
    
 Sorted array: 0 12 17 23 31 37 46 54 72 88 100>