Seřadit Radix je lineární třídicí algoritmus, který třídí prvky tak, že je zpracovává číslici po číslici. Je to účinný třídicí algoritmus pro celá čísla nebo řetězce s klíči pevné velikosti.
Spíše než přímé porovnávání prvků, Radix Sort rozděluje prvky do segmentů na základě hodnoty každé číslice. Opakovaným řazením prvků podle platných číslic, od nejméně významných po nejvýznamnější, Radix Sort dosáhne konečného seřazeného pořadí.
Algoritmus řazení Radix
Klíčovou myšlenkou Radix Sort je využití konceptu hodnoty místa. Předpokládá, že seřazením čísel číslice po číslici nakonec vznikne plně seřazený seznam. Radix Sort lze provádět pomocí různých variací, jako je Radix Sort s nejméně významnou číslicí (LSD) nebo s nejvýznamnější číslicí (MSD) Radix Sort.
Jak funguje Radix Sort Algorithm?
Chcete-li provést radixové řazení na poli [170, 45, 75, 90, 802, 24, 2, 66], postupujte takto:
Jak funguje Radix Sort Algorithm | Krok 1
Krok 1: Najděte největší prvek v poli, což je 802. Má tři číslice, takže budeme opakovat třikrát, jednou pro každé významné místo.
Krok 2: Seřaďte prvky na základě číslic jednotky (X=0). K řazení číslic na každém významném místě používáme stabilní techniku třídění, jako je počítací třídění.
dědičnost v c++Řazení podle místa jednotky:
- Proveďte třídění počítání na poli na základě číslic jednotky.
- Seřazené pole podle místa jednotky je [170, 90, 802, 2, 24, 45, 75, 66].
Jak funguje Radix Sort Algorithm | Krok 2
Krok 3: Seřaďte prvky podle desetinných míst.
obsahuje podřetězec javaŘazení podle místa v desítkách:
- Proveďte řazení počítání na poli na základě desítek míst.
- Seřazené pole na základě desítek je [802, 2, 24, 45, 66, 170, 75, 90].
Jak funguje Radix Sort Algorithm | Krok 3
Krok 4: Seřaďte prvky na základě stovek číslic.
Řazení na základě stovek míst:
- Proveďte řazení počítání na poli na základě stovek míst.
- Seřazené pole na základě stovek je [2, 24, 45, 66, 75, 90, 170, 802].
Jak funguje Radix Sort Algorithm | Krok 4
Krok 5: Pole je nyní seřazeny ve vzestupném pořadí.
Konečné seřazené pole pomocí radix sort je [2, 24, 45, 66, 75, 90, 170, 802].
Jak funguje Radix Sort Algorithm | Krok 5
Níže je uvedena implementace pro výše uvedené ilustrace:
C++ // C++ implementation of Radix Sort #include using namespace std; // A utility function to get maximum // value in arr[] int getMax(int arr[], int n) { int mx = arr[0]; for (int i = 1; i < n; i++) if (arr[i]>mx) mx = arr[i]; návrat mx; } // Funkce pro počítání typu arr[] // podle číslice // reprezentované exp. void countSort(int arr[], int n, int exp) { // Výstupní pole int output[n]; int i, počet[10] = { 0 }; // Uloží počet výskytů // do count[] pro (i = 0; i< n; i++) count[(arr[i] / exp) % 10]++; // Change count[i] so that count[i] // now contains actual position // of this digit in output[] for (i = 1; i < 10; i++) count[i] += count[i - 1]; // Build the output array for (i = n - 1; i>= 0; i--) { output[počet[(arr[i] / exp) % 10] - 1] = arr[i]; počet[(arr[i] / exp) % 10]--; } // Zkopírujte výstupní pole do arr[], // tak, aby arr[] nyní obsahovalo seřazená // čísla podle aktuální číslice pro (i = 0; i< n; i++) arr[i] = output[i]; } // The main function to that sorts arr[] // of size n using Radix Sort void radixsort(int arr[], int n) { // Find the maximum number to // know number of digits int m = getMax(arr, n); // Do counting sort for every digit. // Note that instead of passing digit // number, exp is passed. exp is 10^i // where i is current digit number for (int exp = 1; m / exp>0; exp *= 10) countSort(arr, n, exp); } // Obslužná funkce pro tisk pole void print(int arr[], int n) { for (int i = 0; i< n; i++) cout << arr[i] << ' '; } // Driver Code int main() { int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 }; int n = sizeof(arr) / sizeof(arr[0]); // Function Call radixsort(arr, n); print(arr, n); return 0; }> Jáva // Radix sort Java implementation import java.io.*; import java.util.*; class Radix { // A utility function to get maximum value in arr[] static int getMax(int arr[], int n) { int mx = arr[0]; for (int i = 1; i < n; i++) if (arr[i]>mx) mx = arr[i]; návrat mx; } // Funkce pro počítání typu arr[] podle // číslice reprezentované exp. static void countSort(int arr[], int n, int exp) { int výstup[] = new int[n]; // výstup pole int i; int pocet[] = new int[10]; Arrays.fill(count, 0); // Uloží počet výskytů do count[] pro (i = 0; i< n; i++) count[(arr[i] / exp) % 10]++; // Change count[i] so that count[i] now contains // actual position of this digit in output[] for (i = 1; i < 10; i++) count[i] += count[i - 1]; // Build the output array for (i = n - 1; i>= 0; i--) { output[počet[(arr[i] / exp) % 10] - 1] = arr[i]; počet[(arr[i] / exp) % 10]--; } // Zkopírujte výstupní pole do arr[], takže arr[] nyní // obsahuje čísla seřazená podle aktuální // číslice pro (i = 0; i< n; i++) arr[i] = output[i]; } // The main function to that sorts arr[] of // size n using Radix Sort static void radixsort(int arr[], int n) { // Find the maximum number to know number of digits int m = getMax(arr, n); // Do counting sort for every digit. Note that // instead of passing digit number, exp is passed. // exp is 10^i where i is current digit number for (int exp = 1; m / exp>0; exp *= 10) countSort(arr, n, exp); } // Obslužná funkce pro tisk statického pole void print(int arr[], int n) { for (int i = 0; i< n; i++) System.out.print(arr[i] + ' '); } // Main driver method public static void main(String[] args) { int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 }; int n = arr.length; // Function Call radixsort(arr, n); print(arr, n); } }> Python3 # Python program for implementation of Radix Sort # A function to do counting sort of arr[] according to # the digit represented by exp. def countingSort(arr, exp1): n = len(arr) # The output array elements that will have sorted arr output = [0] * (n) # initialize count array as 0 count = [0] * (10) # Store count of occurrences in count[] for i in range(0, n): index = arr[i] // exp1 count[index % 10] += 1 # Change count[i] so that count[i] now contains actual # position of this digit in output array for i in range(1, 10): count[i] += count[i - 1] # Build the output array i = n - 1 while i>= 0: index = arr[i] // exp1 output[count[index % 10] - 1] = arr[i] count[index % 10] -= 1 i -= 1 # Zkopírování výstupního pole do arr[] , # takže arr nyní obsahuje seřazená čísla i = 0 pro i v rozsahu (0, len(arr)): arr[i] = output[i] # Metoda k provedení Radix Sort def radixSort(arr): # Najděte maximum počet vědět počet číslic max1 = max(arr) # Proveďte počítání třídění pro každou číslici. Všimněte si, že místo # předávaného čísla je předán exp. exp je 10^i # kde i je aktuální číslice číslo exp = 1, zatímco max1 / exp>= 1: countingSort(arr, exp) exp *= 10 # Kód ovladače arr = [170, 45, 75, 90, 802, 24 , 2, 66] # Volání funkce radixSort(arr) pro i v rozsahu(len(arr)): print(arr[i], end=' ') # Tento kód přispěl Mohit Kumra # Editoval Patrick Gallagher>
C# // C# implementation of Radix Sort using System; class GFG { public static int getMax(int[] arr, int n) { int mx = arr[0]; for (int i = 1; i < n; i++) if (arr[i]>mx) mx = arr[i]; návrat mx; } // Funkce pro počítání typu arr[] podle // číslice reprezentované exp. public static void countSort(int[] arr, int n, int exp) { int[] output = new int[n]; // výstup pole int i; int[] počet = nový int[10]; // inicializace všech prvků count na 0 pro (i = 0; i< 10; i++) count[i] = 0; // Store count of occurrences in count[] for (i = 0; i < n; i++) count[(arr[i] / exp) % 10]++; // Change count[i] so that count[i] now contains // actual // position of this digit in output[] for (i = 1; i < 10; i++) count[i] += count[i - 1]; // Build the output array for (i = n - 1; i>= 0; i--) { output[počet[(arr[i] / exp) % 10] - 1] = arr[i]; počet[(arr[i] / exp) % 10]--; } // Zkopírujte výstupní pole do arr[], takže arr[] nyní // obsahuje čísla seřazená podle aktuální // číslice pro (i = 0; i< n; i++) arr[i] = output[i]; } // The main function to that sorts arr[] of size n using // Radix Sort public static void radixsort(int[] arr, int n) { // Find the maximum number to know number of digits int m = getMax(arr, n); // Do counting sort for every digit. Note that // instead of passing digit number, exp is passed. // exp is 10^i where i is current digit number for (int exp = 1; m / exp>0; exp *= 10) countSort(arr, n, exp); } // Obslužná funkce pro tisk pole public static void print(int[] arr, int n) { for (int i = 0; i< n; i++) Console.Write(arr[i] + ' '); } // Driver Code public static void Main() { int[] arr = { 170, 45, 75, 90, 802, 24, 2, 66 }; int n = arr.Length; // Function Call radixsort(arr, n); print(arr, n); } // This code is contributed by DrRoot_ }> Javascript // Radix sort JavaScript implementation 'use strict'; // A utility function to get maximum value in arr[] function getMax(arr) { const length = arr.length; let mx = arr[0]; for (let i = 1; i < length; i++) { if (arr[i]>mx) mx = arr[i]; } return mx; } // Funkce pro počítání typu arr[] podle // číslice reprezentované exp. function countSort(arr, exp) { const length = arr.length; let output = Array(length); // výstup pole let count = Array(10).fill(0, 0); // Uloží počet výskytů do count[] for (ať i = 0; i< length; i++) { const digit = Math.floor(arr[i] / exp) % 10; count[digit]++; } // Change count[i] so that count[i] now contains // actual position of this digit in output[] for (let i = 1; i < 10; i++) { count[i] += count[i - 1]; } // Build the output array for (let i = length - 1; i>= 0; i--) { const digit = Math.floor(arr[i] / exp) % 10; výstup[počet[číslice] - 1] = arr[i]; počet[číslice]--; } návratový výstup; } // Hlavní funkce, která třídí arr[] pomocí funkce Radix Sort radixSort(arr) { // Najděte maximální počet, abyste věděli počet číslic const maxNumber = getMax(arr); // Vytvoří mělkou kopii, kde budou uchovány setříděné hodnoty let sortArr = [...arr]; // Proveďte třídění počítání pro každou číslici. Všimněte si, že // místo předávání číselného čísla se předává exp. // exp je 10^i kde i je aktuální ciferné číslo pro (nech exp = 1; Math.floor(maxNumber / exp)> 0; exp *= 10) { // Získání iterace řazení Const sortIteration = countSort(sortedArr , exp); sortArr = sortedIteration; } return sortedArr; } /*Kód ovladače*/ const arr = [170, 45, 75, 90, 802, 24, 2, 66]; // Volání funkce const sortArr = radixSort(arr); console.log(sortedArr.join(' ')); // Tento kód přispěl beeduhboodee> PHP // PHP implementation of Radix Sort // A function to do counting sort of arr[] // according to the digit represented by exp. function countSort(&$arr, $n, $exp) { $output = array_fill(0, $n, 0); // output array $count = array_fill(0, 10, 0); // Store count of occurrences in count[] for ($i = 0; $i < $n; $i++) $count[ ($arr[$i] / $exp) % 10 ]++; // Change count[i] so that count[i] // now contains actual position of // this digit in output[] for ($i = 1; $i < 10; $i++) $count[$i] += $count[$i - 1]; // Build the output array for ($i = $n - 1; $i>= 0; $i--) { $output[$count[ ($arr[$i] / $exp) % 10 ] - 1] = $arr[$i]; $count[ ($arr[$i] / $exp) % 10 ]--; } // Zkopírujte výstupní pole do arr[], takže // arr[] nyní obsahuje seřazená čísla // podle aktuální číslice pro ($i = 0; $i< $n; $i++) $arr[$i] = $output[$i]; } // The main function to that sorts arr[] // of size n using Radix Sort function radixsort(&$arr, $n) { // Find the maximum number to know // number of digits $m = max($arr); // Do counting sort for every digit. Note // that instead of passing digit number, // exp is passed. exp is 10^i where i is // current digit number for ($exp = 1; $m / $exp>0; $exp *= 10) countSort($arr, $n, $exp); } // Obslužná funkce pro tisk funkce pole PrintArray(&$arr,$n) { for ($i = 0; $i< $n; $i++) echo $arr[$i] . ' '; } // Driver Code $arr = array(170, 45, 75, 90, 802, 24, 2, 66); $n = count($arr); // Function Call radixsort($arr, $n); PrintArray($arr, $n); // This code is contributed by rathbhupendra ?>> Šipka // Radix sort Dart implementation /// A utility function to get the maximum value of a `List` [array] int getMax(List pole) { int max = pole[0]; for (final it in array) { if (it> max) { max = it; } } return max; } /// Funkce pro počítání typu `Seznam` [pole] podle /// číslice reprezentované [exp]. Seznam countSort(Seznam pole, int exp) { konečná délka = pole.délka; final outputArr = List.filled(length, 0); // Seznam, kde index představuje číslici a hodnota představuje počet // výskytů final digitsCount = List.filled(10, 0); // Uloží počet výskytů v digitsCount[] for (konečná položka v poli) { final digit = item ~/ exp % 10; číslicePočet[číslice]++; } // Změňte digitsCount[i] tak, aby digitsCount[i] nyní obsahoval aktuální pozici // této číslice ve outputArr[] for (int i = 1; i< 10; i++) { digitsCount[i] += digitsCount[i - 1]; } // Build the output array for (int i = length - 1; i>= 0; i--) { konečná položka = pole[i]; koncová číslice = položka ~/ exp % 10; outputArr[číslicePočet[číslice] - 1] = položka; číslicePočet[číslice]--; } return outputArr; } /// Hlavní funkce, která třídí `List` [pole] pomocí Radix sort List radixSort(Seznam pole) { // Najděte maximální počet, abyste věděli počet číslic final maxNumber = getMax(array); // Mělká kopie vstupního pole final sortArr = List.of(array); // Proveďte třídění počítání pro každou číslici. Všimněte si, že místo předání číslice // čísla se předá exp. exp je 10^i, kde i je aktuální ciferné číslo pro (int exp = 1; maxNumber ~/ exp> 0; exp *= 10) { final sortIteration = countSort(sortedArr, exp); sortedArr.clear(); sortedArr.addAll(sortedIteration); } return sortedArr; } void main() { const pole = [170, 45, 75, 90, 802, 24, 2, 66]; final sortedArray = radixSort(pole); print(sortedArray); } // Tento kód přispěl beeduhboodee>
Výstup
2 24 45 66 75 90 170 802>
Analýza složitosti Radix Sort :
Časová náročnost:
- Radix sort je nekomparativní celočíselný třídicí algoritmus, který třídí data pomocí celočíselných klíčů seskupováním klíčů podle jednotlivých číslic, které sdílejí stejnou významnou pozici a hodnotu. Má to časovou složitost O(d * (n + b)) , kde d je počet číslic, n je počet prvků a b je základ používané číselné soustavy.
- V praktických implementacích je radixové třídění často rychlejší než jiné třídicí algoritmy založené na porovnání, jako je quicksort nebo slučovací třídění, pro velké datové sady, zvláště když klíče mají mnoho číslic. Jeho časová složitost však roste lineárně s počtem číslic, a proto není pro malé datové sady tak efektivní.
Pomocný prostor:
- Radix sort má také prostorovou složitost O(n + b), kde n je počet prvků a b je základ číselné soustavy. Tato prostorová složitost pochází z potřeby vytvářet segmenty pro každou číselnou hodnotu a kopírovat prvky zpět do původního pole poté, co byla každá číslice seřazena.
Často kladené otázky o RadixSort
Q1. Je Radix Sort vhodnější než třídicí algoritmy založené na porovnání, jako je Quick-Sort?
Pokud máme log2n bitů na každou číslici, doba chodu Radixu se zdá být lepší než Quick Sort pro širokou škálu vstupních čísel. Konstantní faktory skryté v asymptotickém zápisu jsou vyšší pro Radix Sort a Quick-Sort využívá hardwarové mezipaměti efektivněji. Radix sort také používá počítací třídění jako podprogram a počítací třídění zabírá místo navíc k řazení čísel.
Q2. Co když jsou prvky v rozmezí od 1 do n 2 ?
velikosti písma v latexu
- Spodní mez pro třídicí algoritmus založený na porovnání (Merge Sort, Heap Sort, Quick-Sort.. atd.) je Ω(nLogn), tj. nemohou fungovat lépe než nPřihlášení . Počítání třídění je lineární algoritmus časového třídění, který třídí v čase O(n+k), když jsou prvky v rozsahu od 1 do k.
- Nemůžeme použít počítací řazení, protože počítání řazení bude trvat O(n2), což je horší než srovnávací algoritmy řazení. Můžeme takové pole seřadit v lineárním čase?
- Seřadit Radix je odpověď. Myšlenkou Radix Sort je provádět třídění číslice po číslici počínaje nejméně významnou číslicí po nejvýznamnější číslici. Radix sort používá počítací třídění jako podprogram pro třídění.