Binaire invoegsortering is een sorteeralgoritme dat vergelijkbaar is met het invoegsoort , maar in plaats van lineair zoeken te gebruiken om de locatie te vinden waar een element moet worden ingevoegd, gebruiken we Binaire zoekopdracht . We verminderen dus de vergelijkende waarde van het invoegen van een enkel element van O (N) naar O (log N).
Het is een flexibel algoritme, wat betekent dat het sneller werkt als dezelfde gegeven leden al zwaar gesorteerd zijn, dat wil zeggen dat de huidige locatie van het object dichter bij de werkelijke locatie in de gesorteerde lijst ligt.
Het is een stabiel filteralgoritme – elementen met dezelfde waarden verschijnen in dezelfde volgorde in de laatste volgorde als in de eerste lijst.
Toepassingen van binaire invoeging:
- Binaire invoegsortering werkt het beste wanneer de array een lager aantal items bevat.
- Wanneer u snel sorteert of samenvoegt, en de subarraygrootte kleiner wordt (bijvoorbeeld <= 25 elementen), kunt u het beste een binaire invoegsortering gebruiken.
- Dit algoritme werkt ook als de kosten van vergelijkingen tussen sleutels hoog genoeg zijn. Als we bijvoorbeeld meerdere strings willen filteren, zullen de vergelijkingsprestaties van twee strings hoger zijn.
Hoe werkt het sorteren van binaire invoegingen?
- In de sorteermodus voor binaire invoeging verdelen we dezelfde leden in twee subarrays: gefilterd en ongefilterd. Het eerste element van dezelfde leden bevindt zich in de georganiseerde subarray en alle andere elementen zijn niet gepland.
- Vervolgens itereren we van het tweede element naar het laatste. Bij de herhaling van de i-de maken we het huidige object tot onze sleutel. Deze sleutel is een functie die we moeten toevoegen aan onze bestaande lijst hieronder.
- Om dit te doen, gebruiken we eerst een binaire zoekopdracht op de gesorteerde subarray hieronder om de locatie te vinden van een element dat groter is dan onze sleutel. Laten we deze positie pos noemen. Vervolgens verplaatsen we alle elementen naar rechts van pos naar 1 en creëren we Array[pos] = key.
- We kunnen opmerken dat bij elke i-de vermenigvuldiging het linkerdeel van de array tot (i – 1) al is gesorteerd.
Aanpak voor het implementeren van binaire invoegsortering:
- Herhaal de array van het tweede element naar het laatste element.
- Sla het huidige element A[i] op in een variabele sleutel.
- Vind de positie van het element net groter dan A[i] in de subarray van A[0] tot A[i-1] met behulp van binair zoeken. Stel dat dit element zich op indexpositie bevindt.
- Verschuif alle elementen van index pos naar i-1 naar rechts.
- A[pos] = sleutel.
Hieronder vindt u de implementatie van de bovenstaande aanpak:
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[laag]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[midden])> >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] = geselecteerd; } } // Stuurprogrammacode int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; invoegSort(a, n); uit<<'Sorted array:
'; for (i = 0; i cout <<' '<< a[i]; return 0; } // this code is contribution by shivanisinghss2110> |
>
>
C
Java-tupels
// 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>een lage]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[midden])> >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] = geselecteerd; } } // Stuurprogrammacode int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; invoegSort(a, n); printf('Gesorteerde array:
'); 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]>waarde:> >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>einde:> >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 in range(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('Gesorteerde array:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Code bijgedragen door 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[$laag]) ? ($laag + 1): $laag; $midden = (int)(($laag + $hoog) / 2); if($item == $a[$mid]) retourneert $mid + 1; if($item> $a[$mid]) return binarySearch($a, $item, $mid + 1, $high); return binarySearch($a, $item, $low, $mid - 1); } // Functie voor het sorteren van een array a met de grootte 'n' function insertionSort(&$a, $n) { $i; $loc; $j; $ k; $geselecteerd; voor ($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] = $geselecteerd; } } // Stuurprogrammacode $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54); $n = groottevan($a); insertionSort($a, $n); echo 'Gesorteerde array:
'; voor ($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[laag]) ?> >(low + 1) : low;> > >mid = Math.floor((low + high) / 2);> > >if>(item == a[mid])> >return> mid + 1;> > >if>(item>a[midden])> >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--; } // Element op zijn // correcte locatie array[j+1] = x; } } // Stuurprogrammacode let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; sorteer(arr); for (laat i = 0; i document.write(arr[i] + ' '); // Deze code is bijgedragen door onbekende2108 // C-programma voor implementatie van // binaire invoeging sort #include // Een binaire zoekopdracht gebaseerde functie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (high<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerd moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]); r// C-programma voor implementatie van // binaire invoegsortering #include // Een binaire zoekfunctie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { als (hoog<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerd moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]); // C-programma voor implementatie van // binaire invoegsortering # include // Een binaire zoekfunctie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (hoog<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerd moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]); // C-programma voor implementatie van // binaire invoegsortering # include // Een binaire zoekfunctie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (hoog<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerde moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]); // C-programma voor implementatie van // binaire invoegsortering # include // Een binaire zoekfunctie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (hoog<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerd moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]);// C-programma voor implementatie van // binaire invoegsortering # include // Een binaire zoekfunctie // om de positie te vinden // waar het item moet worden ingevoegd // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (hoog<= low) return (item>een lage]) ? (laag + 1): laag; int midden = (laag + hoog) / 2; if (item == a[mid]) retour mid + 1; if (item> a[mid]) retourneert binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Functie voor het sorteren van een array a[] met de grootte 'n' void insertionSort(int a[], int n) { int i, loc, j, k, geselecteerd; for (i = 1; i { j = i - 1; geselecteerd = a[i]; // vind locatie waar geselecteerd moet worden ingevoegd loc = binarySearch(a, geselecteerd, 0, j); // Verplaats alle elementen na locatie om ruimte te creëren while (j>= loc) { a[j + 1] = a[j]; } a[j + 1] = geselecteerd } } // Stuurprogrammacode int main() { int a [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; ); printf('Gesorteerde array:
'); voor (i = 0; i printf('%d ', a[i])> |
>
>Uitvoer
Sorted array: 0 12 17 23 31 37 46 54 72 88 100>
Tijdcomplexiteit: Het algoritme als geheel heeft nog steeds een looptijd van O(n) in het slechtste geval2) vanwege de reeks swaps die voor elke invoeging vereist zijn.
Een andere aanpak: Hieronder volgt een iteratieve implementatie van de bovenstaande recursieve code
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[midden])> >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] = geselecteerd; } } // Stuurprogrammacode int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; invoegSort(a, n); uit<<'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[midden])> >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] = geselecteerd; } } // Stuurprogrammacode int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = groottevan(a) / groottevan(a[0]), i; invoegSort(a, n); printf('Gesorteerde array:
'); for (i = 0; i printf('%d ', a[i]); return 0; } // bijgedragen door tmeid> |
>
>
Java
abstracte klasse
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[midden])> >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] = geselecteerd; } } // Stuurprogrammacode public static void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.lengte, i; invoegSort(a, n); System.out.println('Gesorteerde array:'); for (i = 0; i System.out.print(a[i] +' '); } } // Deze code is bijgedragen door 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[midden])> >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] = geselecteerd; } } // Stuurprogrammacode public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.Lengte, i; invoegSort(a, n); Console.WriteLine('Gesorteerde array:'); for (i = 0; i Console.Write(a[i] +' '); } } // Deze code is bijgedragen door 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[midden])> >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] = geselecteerd; } } // Stuurprogrammacode var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ]; var n = a.lengte, i; invoegSort(a, n); document.write('Gesorteerde array:' + ' '); for (i = 0; i document.write(a[i] +' '); // Deze code is bijgedragen door shivanisinghss2110> |
>
>Uitvoer
Sorted array: 0 12 17 23 31 37 46 54 72 88 100>