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
alfabeto numerato
// 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(n2) 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>