logo

TechCodeview

Orden de inserción binaria

La clasificación por inserción binaria es un algoritmo de clasificación similar al tipo de inserción , pero en lugar de usar la búsqueda lineal para encontrar la ubicación donde se debe insertar un elemento, usamos búsqueda binaria . Por lo tanto, reducimos el valor comparativo de insertar un solo elemento de O (N) a O (log N).

Es un algoritmo flexible, lo que significa que funciona más rápido cuando los mismos miembros dados ya están muy ordenados, es decir, la ubicación actual de la característica está más cerca de su ubicación real en la lista ordenada.



Es un algoritmo de filtrado estable: los elementos con los mismos valores aparecen en la misma secuencia en el último orden que en la primera lista.

Aplicaciones del tipo de inserción binaria:

  • La ordenación por inserción binaria funciona mejor cuando la matriz tiene una cantidad menor de elementos.
  • Al realizar una clasificación rápida o una clasificación por combinación, cuando el tamaño del subarreglo se vuelve más pequeño (digamos <= 25 elementos), es mejor utilizar una clasificación por inserción binaria.
  • Este algoritmo también funciona cuando el coste de las comparaciones entre claves es lo suficientemente alto. Por ejemplo, si queremos filtrar varias cadenas, el rendimiento de comparación de dos cadenas será mayor.

¿Cómo funciona la ordenación por inserción binaria?

  • En el modo de ordenación por inserción binaria, dividimos los mismos miembros en dos subarreglos: filtrados y sin filtrar. El primer elemento de los mismos miembros está en el subconjunto organizado y todos los demás elementos no están planificados.
  • Luego iteramos desde el segundo elemento hasta el último. En la repetición del i-ésimo, hacemos del objeto actual nuestra clave. Esta clave es una característica que deberíamos agregar a nuestra lista existente a continuación.
  • Para hacer esto, primero usamos una búsqueda binaria en el subarreglo ordenado a continuación para encontrar la ubicación de un elemento más grande que nuestra clave. Llamemos a esta posición pos. Luego desplazamos a la derecha todos los elementos de pos a 1 y creamos Array[pos] = clave.
  • Podemos observar que en cada i-ésima multiplicación, la parte izquierda de la matriz hasta (i – 1) ya está ordenada.

Enfoque para implementar la clasificación por inserción binaria:

  • Itere la matriz desde el segundo elemento hasta el último elemento.
  • Almacene el elemento actual A[i] en una clave variable.
  • Encuentre la posición del elemento apenas mayor que A[i] en el subarreglo de A[0] a A[i-1] usando búsqueda binaria. Digamos que este elemento está en el índice pos.
  • Mueva todos los elementos del índice pos a i-1 hacia la derecha.
  • A[pos] = clave.

A continuación se muestra la implementación del enfoque 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[bajo]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mediados])> >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] = seleccionado; } } // Código del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ordenación de inserción (a, n); corte<<'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[bajo])?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mediados])> >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] = seleccionado; } } // Código del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ordenación de inserción (a, n); printf('Matriz ordenada: '); para (i = 0; i printf('%d ', a[i]); retorno 0; }>

hacer mientras bucle 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> 

>

>

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]>valor:> >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>fin:> >return> start> >mid>=> (start>+>end)>/>/>2> >if> arr[mid] return binary_search(arr, val, mid+1, end) elif arr[mid]>val: devuelve búsqueda_binaria(arr, val, inicio, mid-1) más: devuelve definición media insertion_sort(arr): para i en rango(1, len(arr)): val = arr[i] j = búsqueda_binaria(arr, val, 0, i-1) arr = arr[:j] + [val] + arr[j:i] + arr[i+1:] return arr print('Matriz ordenada:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Código aportado por Mohit Gupta_OMG> 

>

>

C#




carácter a int en java

// 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[$bajo])? ($bajo + 1): $bajo; $medio = (int)(($bajo + $alto) / 2); if($item == $a[$mid]) devuelve $mid + 1; if($item> $a[$mid]) return binarioSearch($a, $item, $mid + 1, $high); return binarioSearch($a, $item, $bajo, $mid - 1); } // Función para ordenar una matriz a de tamaño 'n' function insertionSort(&$a, $n) { $i; $loc; $j; $k; $seleccionado; para ($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] = $seleccionado; } } // Código del controlador $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54); $n = tamaño de ($a); inserciónOrdenar($a, $n); echo 'Matriz ordenada: '; para ($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[bajo]) ?> >(low + 1) : low;> > >mid = Math.floor((low + high) / 2);> > >if>(item == a[mid])> >return> mid + 1;> > >if>(item>a[mediados])> >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) { matriz[j + 1] = matriz[j]; j--; } // Colocando el elemento en su // ubicación correcta array[j+1] = x; } } // Código del controlador let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; ordenar(arreglar); for (let i = 0; i document.write(arr[i] + ' '); // Este código es aportado por desconocido2108 // Programa C para la implementación de // ordenación por inserción binaria #include // Una búsqueda binaria función basada // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { if (high<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // busca la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]); r// Programa C para la implementación de // ordenación por inserción binaria. #include // Una función basada en búsqueda binaria // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { si (alto<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // buscar la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]); // Programa C para la implementación de // ordenación por inserción binaria # incluir // Una función basada en búsqueda binaria // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { if (alto<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // buscar la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]); // Programa C para la implementación de // ordenación por inserción binaria # incluir // Una función basada en búsqueda binaria // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { if (alto<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // busca la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]); // Programa C para la implementación de // ordenación por inserción binaria # incluir // Una función basada en búsqueda binaria // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { if (alto<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // buscar la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]);// Programa C para la implementación de // ordenación por inserción binaria # incluir // Una función basada en búsqueda binaria // para encontrar la posición // donde se debe insertar el elemento // en a[low..high] int binarioSearch(int a[], int item, int low, int high) { if (alto<= low) return (item>a[bajo])? (bajo + 1): bajo; int medio = (bajo + alto) / 2; if (item == a[mid]) devuelve mid + 1; if (item> a[mid]) return binarioSearch(a, item, mid + 1, high); return binarioSearch(a, item, low, mid - 1); } // Función para ordenar una matriz a[] de tamaño 'n' void insertionSort(int a[], int n) { int i, loc, j, k, selected; for (i = 1; i { j = i - 1; seleccionado = a[i]; // buscar la ubicación donde se debe insertar lo seleccionado loc = binarioSearch(a, seleccionado, 0, j); // Mover todos los elementos después de la ubicación para crear espacio while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = seleccionado } } // Código de controlador int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i])> 

>

>

Producción 

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

Complejidad del tiempo: El algoritmo en su conjunto todavía tiene un tiempo de ejecución en el peor de los casos de O(n2) debido a la serie de permutas requeridas para cada inserción.

java mientras condición

Otro enfoque: A continuación se muestra una implementación iterativa del código recursivo 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[mediados])> >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] = seleccionado; } } // Código del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ordenación de inserción (a, n); corte<<'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[mediados])> >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] = seleccionado; } } // Código del controlador int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = tamaño de (a) / tamaño de (a [0]), i; ordenación de inserción (a, n); printf('Matriz ordenada: '); for (i = 0; i printf('%d ', a[i]); return 0; } // contribuido por 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[mediados])> >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] = seleccionado; } } // Código 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; ordenación de inserción (a, n); System.out.println('Matriz ordenada:'); for (i = 0; i System.out.print(a[i] +' '); } } // Este código es una contribución de 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[medio]):> >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[mediados])> >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] = seleccionado; } } // Código 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; ordenación de inserción (a, n); Console.WriteLine('Matriz ordenada:'); for (i = 0; i Console.Write(a[i] +' '); } } // Este código es una contribución de shivanisinghss2110> 

>

>

JavaScript


diferencia entre árbol binario y árbol de búsqueda binaria



> // 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[mediados])> >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] = seleccionado; } } // Código de controlador var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ]; var n = a.longitud, i; ordenación de inserción (a, n); document.write('Matriz ordenada:' + ' '); for (i = 0; i document.write(a[i] +' '); // Este código es una contribución de shivanisinghss2110> 

>

>

Producción 

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