L'ordinamento per inserimento binario è un algoritmo di ordinamento simile a ordinamento di inserimento , ma invece di utilizzare la ricerca lineare per trovare la posizione in cui inserire un elemento, utilizziamo ricerca binaria . Pertanto, riduciamo il valore comparativo dell'inserimento di un singolo elemento da O (N) a O (log N).

È un algoritmo flessibile, il che significa che funziona più velocemente quando gli stessi membri sono già fortemente ordinati, ovvero la posizione corrente dell'elemento è più vicina alla sua posizione effettiva nell'elenco ordinato.

Si tratta di un algoritmo di filtraggio stabile: gli elementi con gli stessi valori appaiono nella stessa sequenza nell'ultimo ordine in cui erano nel primo elenco.

Applicazioni dell'ordinamento per inserzione binaria:

• L'ordinamento per inserimento binario funziona meglio quando l'array ha un numero inferiore di elementi.
• Quando si esegue l'ordinamento rapido o l'ordinamento per unione, quando la dimensione del sottoarray diventa più piccola (diciamo <= 25 elementi), è meglio utilizzare un ordinamento per inserimento binario.
• Questo algoritmo funziona anche quando il costo del confronto tra le chiavi è sufficientemente elevato. Ad esempio, se vogliamo filtrare più stringhe, la prestazione di confronto di due stringhe sarà maggiore.

Come funziona l'ordinamento per inserimento binario?

• Nella modalità di ordinamento per inserimento binario, dividiamo gli stessi membri in due sottoarray: filtrati e non filtrati. Il primo elemento degli stessi membri si trova nel sottoarray organizzato e tutti gli altri elementi non sono pianificati.
• Quindi iteriamo dal secondo all'ultimo elemento. Nella ripetizione dell'i-esimo, rendiamo l'oggetto corrente la nostra chiave. Questa chiave è una funzionalità che dovremmo aggiungere al nostro elenco esistente di seguito.
• Per fare ciò, utilizziamo prima una ricerca binaria sul sottoarray ordinato sottostante per trovare la posizione di un elemento più grande della nostra chiave. Chiamiamo questa posizione pos. Quindi spostiamo a destra tutti gli elementi da pos a 1 e creiamo Array[pos] = key.
• Possiamo notare che in ogni i-esima moltiplicazione, la parte sinistra dell'array fino a (i – 1) è già ordinata.

Approccio per implementare l'ordinamento di inserimento binario:

• Itera l'array dal secondo elemento all'ultimo elemento.
• Memorizza l'elemento corrente A[i] in una chiave variabile.
• Trova la posizione dell'elemento appena maggiore di A[i] nel sottoarray da A[0] a A[i-1] utilizzando la ricerca binaria. Supponiamo che questo elemento sia nell'indice pos.
• Sposta tutti gli elementi dall'indice pos a i-1 verso destra.
• A[pos] = chiave.

Di seguito è riportata l'implementazione dell'approccio di cui sopra:

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[basso]) ?> > (low + 1) : low;> > int> mid = (low + high) / 2;> > if> (item == a[mid])> > return> mid + 1;> > if> (item>a[metà])> > 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] = selezionato; } } // Codice driver int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensionedi(a) / dimensionedi(a[0]), i; inserimentoSort(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[basso]) ?> > (low + 1) : low;> > int> mid = (low + high) / 2;> > if> (item == a[mid])> > return> mid + 1;> > if> (item>a[metà])> > 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] = selezionato; } } // Codice driver int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensionedi(a) / dimensionedi(a[0]), i; inserimentoSort(a, n); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); return 0; }>

Giava

// 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>fine:> > return> start> > mid> => (start> +> end)> /> /> 2> > if> arr[mid] return binary_search(arr, val, mid+1, end) elif arr[mid]>val: return ricerca_binaria(arr, val, start, mid-1) else: return mid def inserimento_sort(arr): for i in range(1, len(arr)): val = arr[i] j = ricerca_binaria(arr, val, 0, i-1) arr = arr[:j] + [val] + arr[j:i] + arr[i+1:] return arr print('Array ordinato:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Codice contribuito da Mohit Gupta_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[$basso]) ? ($basso + 1): $basso; $medio = (int)(($basso + $alto) / 2); if($oggetto == $a[$mid]) return $mid + 1; if($oggetto> $a[$mid]) return ricerca binaria($a, $oggetto, $mid + 1, $alto); return ricercabinaria($a, $oggetto, $basso, $medio - 1); } // Funzione per ordinare un array a di dimensione 'n' function insertSort(&$a, $n) { $i; $loc; $j; $k; $selezionato; 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] = $selezionato; } } // Codice driver $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54); $n = dimensionedi($a); inserimentoordinamento($a, $n); echo 'Array ordinato: '; 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[basso]) ?> > (low + 1) : low;> > > mid = Math.floor((low + high) / 2);> > > if> (item == a[mid])> > return> mid + 1;> > > if> (item>a[metà])> > 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--; } // Posiziona l'elemento nella // posizione corretta array[j+1] = x; } } // Codice driver let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; sort(arr); for (let i = 0; i document.write(arr[i] + ' '); // Questo codice è fornito da Unknown2108 // Programma C per l'implementazione di // inserimento binario sort #include // Una ricerca binaria funzione basata // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { if (high <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); r// Programma C per l'implementazione // dell'ordinamento per inserimento binario #include // Una funzione basata sulla ricerca binaria // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { se (alto <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); // Programma C per l'implementazione di // ordinamento per inserimento binario # include // Una funzione basata sulla ricerca binaria // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { if (alto <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); // Programma C per l'implementazione di // ordinamento per inserimento binario # include // Una funzione basata sulla ricerca binaria // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { if (alto <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); // Programma C per l'implementazione di // ordinamento per inserimento binario # include // Una funzione basata sulla ricerca binaria // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { if (alto <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]);// Programma C per l'implementazione di // ordinamento per inserimento binario # include // Una funzione basata sulla ricerca binaria // per trovare la posizione // in cui inserire l'elemento // in a[low..high] int BinarySearch(int a[], int item, int low, int high) { if (alto <= low) return (item>a[basso]) ? (basso + 1): basso; int medio = (basso + alto) / 2; if (oggetto == a[mid]) return mid + 1; if (oggetto> a[mid]) return BinarySearch(a, oggetto, mid + 1, high); return BinarySearch(a, item, low, mid - 1); } // Funzione per ordinare un array a[] di dimensione 'n' void insertSort(int a[], int n) { int i, loc, j, k, selezionato; for (i = 1; i { j = i - 1; selezionato = a[i]; // trova la posizione in cui dovrebbe essere inserito selezionato loc = BinarySearch(a, selezionato, 0, j); // Sposta tutti gli elementi dopo la posizione per creare spazio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = selezionato; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensione(a) / dimensione(a[0]), i; insertSort(a, n ); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i])>

Produzione

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

Complessità temporale: L'algoritmo nel suo insieme ha ancora un tempo di esecuzione nel caso peggiore pari a O(n ² ) a causa della serie di scambi richiesti per ogni inserimento.

Un altro approccio: Di seguito è riportata un'implementazione iterativa del codice ricorsivo di cui sopra

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[metà])> > 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] = selezionato; } } // Codice driver int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensionedi(a) / dimensionedi(a[0]), i; inserimentoSort(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[metà])> > 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] = selezionato; } } // Codice driver int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = dimensionedi(a) / dimensionedi(a[0]), i; inserimentoSort(a, n); printf('Array ordinato: '); for (i = 0; i printf('%d ', a[i]); return 0; } // contribuito da tmeid>

Giava

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[metà])> > 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] = selezionato; } } // Codice driver public static void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.lunghezza, i; inserimentoSort(a, n); System.out.println('Array ordinato:'); for (i = 0; i System.out.print(a[i] +' '); } } // Questo codice è fornito da 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[metà]):> > 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[metà])> > 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] = selezionato; } } // Codice driver public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.Lunghezza, i; inserimentoSort(a, n); Console.WriteLine('Array ordinato:'); for (i = 0; i Console.Write(a[i] +' '); } } // Questo codice è fornito da shivanisinghss2110>

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[metà])> > 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] = selezionato; } } // Codice driver var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ]; var n = a.lunghezza, i; inserimentoSort(a, n); document.write('Array ordinato:' + ' '); for (i = 0; i document.write(a[i] +' '); // Questo codice è fornito da shivanisinghss2110>

Produzione

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