Binární řazení je třídicí algoritmus, který je podobný řazení vložení , ale místo lineárního vyhledávání k nalezení místa, kam by měl být prvek vložen, používáme binární vyhledávání . Tím snížíme srovnávací hodnotu vložení jediného prvku z O (N) na O (log N).
Jedná se o flexibilní algoritmus, což znamená, že pracuje rychleji, když jsou stejné dané členy již silně seřazeny, tj. aktuální umístění prvku je blíže jeho skutečnému umístění v seřazeném seznamu.
Jedná se o stabilní filtrovací algoritmus – prvky se stejnými hodnotami se objevují ve stejném pořadí v posledním pořadí, jako byly v prvním seznamu.
Aplikace řazení binárního vkládání:
- Binární řazení funguje nejlépe, když má pole nižší počet položek.
- Když provádíte rychlé třídění nebo slučovací třídění, když se velikost podpole zmenší (řekněme <= 25 prvků), je nejlepší použít binární vkládání.
- Tento algoritmus také funguje, když jsou náklady na porovnávání mezi klíči dostatečně vysoké. Chceme-li například filtrovat více řetězců, bude výkon porovnání dvou řetězců vyšší.
Jak funguje třídění binárního vkládání?
- V režimu řazení binárním vkládáním rozdělujeme stejné členy do dvou podpolí – filtrované a nefiltrované. První prvek stejných členů je v organizovaném podpole a všechny ostatní prvky jsou neplánované.
- Poté iterujeme od druhého prvku k poslednímu. Při opakování i-tého uděláme z aktuálního objektu náš klíč. Tento klíč je funkce, kterou bychom měli přidat do našeho stávajícího seznamu níže.
- Abychom toho dosáhli, nejprve použijeme binární vyhledávání na seřazeném podpolí níže, abychom našli umístění prvku většího než náš klíč. Nazvěme tuto pozici poz. Potom jsme všechny prvky posunuli doprava z pozice na 1 a vytvořili jsme Array[pos] = key.
- Můžeme si všimnout, že při každém i-tém násobení je levá část pole till (i – 1) již setříděna.
Přístup k implementaci řazení binárního vkládání:
- Iterujte pole od druhého prvku k poslednímu prvku.
- Uložte aktuální prvek A[i] do proměnného klíče.
- Najděte polohu prvku právě větší než A[i] v dílčím poli od A[0] do A[i-1] pomocí binárního vyhledávání. Řekněme, že tento prvek je na pozici indexu.
- Posuňte všechny prvky z pozice indexu na i-1 směrem doprava.
- A[pos] = klíč.
Níže je uvedena implementace výše uvedeného přístupu:
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[nízká]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mid])> >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] = vybráno; } } // Kód ovladače int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; insertionSort(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[nízká]) ?> >(low + 1) : low;> >int> mid = (low + high) / 2;> >if> (item == a[mid])> >return> mid + 1;> >if> (item>a[mid])> >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] = vybráno; } } // Kód ovladače int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; insertionSort(a, n); printf('Seřazené pole:
'); for (i = 0; i printf('%d ', a[i]); return 0; }> |
>
>
Jáva
// 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> |
>
java databáze jdbc
>
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>konec:> >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('Sorted array:') print(insertion_sort( [37, 23, 0, 31, 22, 17, 12, 72, 31, 46, 100, 88, 54])) # Kód přispěl 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[$low]) ? ($nízký + 1) : $nízký; $střed = (int)(($nízký + $vysoký) / 2); if($item == $a[$mid]) return $mid + 1; if($item> $a[$mid]) return binarySearch($a, $item, $mid + 1, $high); return binarySearch($a, $položka, $nízká, $střední - 1); } // Funkce pro třídění pole a o velikosti 'n' function insertionSort(&$a, $n) { $i; $loc; $j; $k; $vybrano; pro ($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] = $vybrano; } } // Kód ovladače $a = array(37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54); $n = sizeof($a); insertionSort($a, $n); echo 'Seřazené pole:
'; pro ($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[nízká]) ?> >(low + 1) : low;> > >mid = Math.floor((low + high) / 2);> > >if>(item == a[mid])> >return> mid + 1;> > >if>(item>a[mid])> >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) { pole[j + 1] = pole[j]; j--; } // Umístění prvku na // správné umístění array[j+1] = x; } } // Kód ovladače let arr=[ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]; sort(arr); for (nechť i = 0; i document.write(arr[i] + ' '); // Tento kód je vytvořen neznámým2108 // C program pro implementaci // binárního vkládání sort #include // Binární vyhledávání založená funkce // k nalezení pozice // kam má být položka vložena // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (high<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; printf('Seřazené pole:
' pro (i = 0; i printf('%d ', a[i]); r// C program pro implementaci // binárního vkládání řazení); #include // Funkce založená na binárním vyhledávání // k nalezení pozice // kam má být položka vložena // do a[nízká..vysoká] int binarySearch(int a[], int položka, int nízká, int vysoká) { pokud (vysoký<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; printf('Seřazené pole:
' for (i = 0; i printf('%d ', a[i]); // C program pro implementaci // binárního vkládání sort #); include // Binární funkce založená na vyhledávání // k nalezení pozice // kam má být položka vložena // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (vysoký<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; printf('Seřazené pole:
' for (i = 0; i printf('%d ', a[i]); // C program pro implementaci // binárního vkládání sort #); include // Binární funkce založená na vyhledávání // k nalezení pozice // kam má být položka vložena // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (vysoký<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; printf('Seřazené pole:
' for (i = 0; i printf('%d ', a[i]); // C program pro implementaci // binárního vkládání sort #); include // Binární funkce založená na vyhledávání // k nalezení pozice // kam má být položka vložena // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (vysoký<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; ); printf('Seřazené pole:
' for (i = 0; i printf('%d ', a[i]);// C program pro implementaci // binárního vkládání sort #); include // Binární funkce založená na vyhledávání // k nalezení pozice // kam má být položka vložena // in a[low..high] int binarySearch(int a[], int item, int low, int high) { if (vysoký<= low) return (item>a[nízká]) ? (nízká + 1) : nízká; int mid = (nízká + vysoká) / 2; if (položka == a[mid]) return mid + 1; if (položka> a[mid]) return binarySearch(a, item, mid + 1, high); return binarySearch(a, item, low, mid - 1); } // Funkce pro řazení pole a[] o velikosti 'n' void insertionSort(int a[], int n) { int i, loc, j, k, vybráno; for (i = 1; i { j = i - 1; vybrané = a[i]; // najít umístění, kam má být vybráno vloženo loc = binarySearch(a, vybrané, 0, j); // Přesunout všechny prvky za umístění pro vytvoření prostoru while (j>= loc) { a[j + 1] = a[j] j--; } a[j + 1] = vybráno } // Kód ovladače int main() { int a; [] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; printf('Seřazené pole:
' pro (i = 0; i printf('%d ', a[i])> |
>
>Výstup
Sorted array: 0 12 17 23 31 37 46 54 72 88 100>
Časová náročnost: Algoritmus jako celek má stále běžící nejhorší případ běhu O(n2) kvůli sérii swapů požadovaných pro každé vložení.
Jiný přístup: Následuje iterativní implementace výše uvedeného rekurzivního kódu
C++
entita vztahová
#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[mid])> >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] = vybráno; } } // Kód ovladače int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; insertionSort(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[mid])> >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] = vybráno; } } // Kód ovladače int main() { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = velikost(a) / velikost(a[0]), i; insertionSort(a, n); printf('Seřazené pole:
'); for (i = 0; i printf('%d ', a[i]); return 0; } // přispěl tmeid> |
>
>
Jáva
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[mid])> >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] = vybráno; } } // Kód ovladače public static void main (String[] args) { int a[] = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.délka, i; insertionSort(a, n); System.out.println('Seřazené pole:'); for (i = 0; i System.out.print(a[i] +' '); } } // Tento kód přispěl 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[mid])> >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] = vybráno; } } // Kód ovladače public static void Main (String[] args) { int []a = { 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 }; int n = a.Délka, i; insertionSort(a, n); Console.WriteLine('Seřazené pole:'); for (i = 0; i Console.Write(a[i] +' '); } } // Tento kód přispěl 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[mid])> >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] = vybráno; } } // Kód ovladače var a = [ 37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54 ]; var n = a.délka, i; insertionSort(a, n); document.write('Seřazené pole:' + ' '); for (i = 0; i document.write(a[i] +' '); // Tento kód přispěl shivanisinghss2110> |
>
mysql změnit typ sloupce
>Výstup
Sorted array: 0 12 17 23 31 37 46 54 72 88 100>