Trier la base est un algorithme de tri linéaire qui trie les éléments en les traitant chiffre par chiffre. Il s'agit d'un algorithme de tri efficace pour les entiers ou les chaînes avec des clés de taille fixe.
Plutôt que de comparer directement les éléments, Radix Sort distribue les éléments dans des compartiments en fonction de la valeur de chaque chiffre. En triant à plusieurs reprises les éléments selon leurs chiffres significatifs, du moins significatif au plus significatif, Radix Sort obtient l'ordre de tri final.
Algorithme de tri de base
L'idée clé derrière Radix Sort est d'exploiter le concept de valeur de position. Il suppose que le tri des nombres chiffre par chiffre aboutira finalement à une liste entièrement triée. Le tri par base peut être effectué en utilisant différentes variantes, telles que le tri par base du chiffre le moins significatif (LSD) ou le tri par base du chiffre le plus significatif (MSD).
Comment fonctionne l'algorithme de tri Radix ?
Pour effectuer un tri par base sur le tableau [170, 45, 75, 90, 802, 24, 2, 66], nous suivons ces étapes :
Comment fonctionne l'algorithme de tri Radix | Étape 1
Étape 1: Trouvez le plus grand élément du tableau, qui est 802. Il comporte trois chiffres, nous allons donc itérer trois fois, une fois pour chaque place significative.
Étape 2: Triez les éléments en fonction des chiffres de la place de l'unité (X=0). Nous utilisons une technique de tri stable, telle que le tri par comptage, pour trier les chiffres à chaque endroit significatif.
scanner en javaTri selon la place unitaire :
- Effectuez un tri par comptage sur le tableau en fonction des chiffres de la place de l'unité.
- Le tableau trié en fonction de la place de l'unité est [170, 90, 802, 2, 24, 45, 75, 66].
Comment fonctionne l'algorithme de tri Radix | Étape 2
Étape 3: Triez les éléments en fonction des chiffres des dizaines.
Tri basé sur les dizaines :
- Effectuez un tri par comptage sur le tableau en fonction des chiffres des dizaines.
- Le tableau trié basé sur la position des dizaines est [802, 2, 24, 45, 66, 170, 75, 90].
Comment fonctionne l'algorithme de tri Radix | Étape 3
Étape 4: Triez les éléments en fonction des chiffres des centaines.
Tri basé sur la place des centaines :
- Effectuez un tri par comptage sur le tableau en fonction des chiffres des centaines.
- Le tableau trié basé sur la position des centaines est [2, 24, 45, 66, 75, 90, 170, 802].
Comment fonctionne l'algorithme de tri Radix | Étape 4
Étape 5 : Le tableau est désormais trié par ordre croissant.
quelle est la taille de mon écran d'ordinateurLe tableau trié final utilisant le tri par base est [2, 24, 45, 66, 75, 90, 170, 802].
Comment fonctionne l'algorithme de tri Radix | Étape 5
Vous trouverez ci-dessous la mise en œuvre des illustrations ci-dessus :
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[je]; retourner mx ; } // Une fonction pour compter une sorte de arr[] // selon le chiffre // représenté par exp. void countSort(int arr[], int n, int exp) { // Tableau de sortie int output[n]; int je, compte[10] = { 0 } ; // Stocke le nombre d'occurrences // dans count[] pour (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--) { sortie[count[(arr[i] / exp) % 10] - 1] = arr[i]; compte[(arr[i] / exp) % 10]--; } // Copie le tableau de sortie dans arr[], // de sorte que arr[] contienne maintenant des // nombres triés en fonction du chiffre actuel pour (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); } // Une fonction utilitaire pour imprimer un tableau 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; }> Java // 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[je]; retourner mx ; } // Une fonction pour compter une sorte de arr[] en fonction // du chiffre représenté par exp. static void countSort(int arr[], int n, int exp) { int output[] = new int[n]; // tableau de sortie int i ; int count[] = nouveau int[10]; Arrays.fill(count, 0); // Stocke le nombre d'occurrences dans count[] pour (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--) { sortie[count[(arr[i] / exp) % 10] - 1] = arr[i]; compte[(arr[i] / exp) % 10]--; } // Copie le tableau de sortie dans arr[], de sorte que arr[] contienne maintenant // des nombres triés en fonction du // chiffre actuel pour (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); } // Une fonction utilitaire pour imprimer un tableau static 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 # Copie du tableau de sortie dans arr[] , # pour que arr contienne maintenant des nombres triés i = 0 pour i in range(0, len(arr)) : arr[i] = output[i] # Méthode pour faire Radix Sort def radixSort(arr) : # Trouver le maximum nombre pour connaître le nombre de chiffres max1 = max(arr) # Effectuez un tri par comptage pour chaque chiffre. Notez qu'au lieu du nombre de chiffres passant, exp est transmis. exp est 10^i # où i est le numéro de chiffre actuel exp = 1 tandis que max1 / exp>= 1 : countingSort(arr, exp) exp *= 10 # Code du pilote arr = [170, 45, 75, 90, 802, 24 , 2, 66] # Appel de fonction radixSort(arr) pour i in range(len(arr)): print(arr[i], end=' ') # Ce code est contribué par Mohit Kumra # Edité par 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[je]; retourner mx ; } // Une fonction pour compter une sorte de arr[] en fonction // du chiffre représenté par exp. public static void countSort(int[] arr, int n, int exp) { int[] sortie = new int[n]; // tableau de sortie int i ; int[] compte = nouveau int[10]; // initialisation de tous les éléments de count à 0 pour (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--) { sortie[count[(arr[i] / exp) % 10] - 1] = arr[i]; compte[(arr[i] / exp) % 10]--; } // Copie le tableau de sortie dans arr[], de sorte que arr[] contienne maintenant // des nombres triés en fonction du // chiffre actuel pour (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); } // Une fonction utilitaire pour imprimer un tableau 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[je]; } renvoie mx ; } // Une fonction pour compter une sorte de arr[] en fonction // du chiffre représenté par exp. function countSort(arr, exp) { const length = arr.length; let output = Array(longueur); // tableau de sortie let count = Array(10).fill(0, 0); // Stocke le nombre d'occurrences dans count[] pour (soit 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; sortie[count[digit] - 1] = arr[i]; compter[chiffre]--; } renvoie la sortie ; } // La fonction principale qui trie arr[] en utilisant la fonction Radix Sort radixSort(arr) { // Trouver le nombre maximum pour connaître le nombre de chiffres const maxNumber = getMax(arr); // Crée une copie superficielle où les valeurs triées seront conservées let sortedArr = [...arr]; // Effectue un tri par comptage pour chaque chiffre. Notez que // au lieu de transmettre un nombre numérique, exp est transmis. // exp est 10^i où i est le numéro de chiffre actuel pour (soit exp = 1; Math.floor(maxNumber / exp)> 0; exp *= 10) { // Obtenez l'itération de tri Count const sortedIteration = countSort(sortedArr , exp); sortedArr = sortedIteration ; } return sortedArr; } /*Code du pilote*/ const arr = [170, 45, 75, 90, 802, 24, 2, 66]; // Appel de fonction const sortedArr = radixSort(arr); console.log(sortedArr.join(' ')); // Ce code est contribué par 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 ]--; } // Copie le tableau de sortie dans arr[], de sorte // que arr[] contienne maintenant des nombres triés // selon le chiffre actuel pour ($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); } // Une fonction utilitaire pour imprimer une fonction de tableau 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 ?>> Dard // Radix sort Dart implementation /// A utility function to get the maximum value of a `List` [array] int getMax(List tableau) { int max = tableau[0]; for (final it in array) { if (it> max) { max = it ; } } renvoie max ; } /// Une fonction pour compter une sorte de `List` [array] en fonction du /// chiffre représenté par [exp]. Liste countTri(Liste tableau, int exp) { longueur finale = tableau.longueur; sortie finaleArr = List.filled(longueur, 0); // Une liste où index représente le chiffre et value représente le nombre d'occurrences // final digitsCount = List.filled(10, 0); // Stocke le nombre d'occurrences dans digitsCount[] pour (dernier élément du tableau) { final digit = item ~/ exp % 10; chiffresCount[chiffre]++; } // Modifiez digitsCount[i] pour que digitsCount[i] contienne désormais la position réelle // de ce chiffre dans outputArr[] pour (int i = 1; i< 10; i++) { digitsCount[i] += digitsCount[i - 1]; } // Build the output array for (int i = length - 1; i>= 0 ; i--) { élément final = tableau[i]; chiffre final = article ~/ exp % 10 ; outputArr[digitsCount[digit] - 1] = élément ; chiffresCount[chiffre]--; } return sortieArr; } /// La fonction principale qui trie une `List` [tableau] en utilisant la liste de tri Radix radixTri(Liste array) { // Trouver le nombre maximum pour connaître le nombre de chiffres final maxNumber = getMax(array); // Copie superficielle du tableau d'entrée final sortedArr = List.of(array); // Effectue un tri par comptage pour chaque chiffre. Notez qu'au lieu de transmettre un chiffre // nombre, exp est transmis. exp est 10^i, où i est le chiffre actuel pour (int exp = 1; maxNumber ~/ exp> 0; exp *= 10) { final sortedIteration = countSort(sortedArr, exp); sortedArr.clear(); sortedArr.addAll(sortedIteration); } return sortedArr; } void main() { tableau const = [170, 45, 75, 90, 802, 24, 2, 66]; final sortedArray = radixSort(array); print(tableautrié); } // Ce code est contribué par beeduhboodee>
Sortir
2 24 45 66 75 90 170 802>
Analyse de complexité du tri Radix :
Complexité temporelle :
- Le tri Radix est un algorithme de tri d'entiers non comparatif qui trie les données avec des clés entières en regroupant les clés par chiffres individuels qui partagent la même position et la même valeur significative. Il a une complexité temporelle de O(d * (n + b)) , où d est le nombre de chiffres, n est le nombre d'éléments et b est la base du système numérique utilisé.
- Dans les implémentations pratiques, le tri par base est souvent plus rapide que d'autres algorithmes de tri basés sur des comparaisons, tels que le tri rapide ou le tri par fusion, pour les grands ensembles de données, en particulier lorsque les clés comportent de nombreux chiffres. Cependant, sa complexité temporelle augmente linéairement avec le nombre de chiffres et n’est donc pas aussi efficace pour les petits ensembles de données.
Espace auxiliaire :
différence entre entreprise et entreprise
- Le tri Radix a également une complexité spatiale de O(n+b), où n est le nombre d'éléments et b est la base du système numérique. Cette complexité spatiale vient de la nécessité de créer des compartiments pour chaque valeur numérique et de recopier les éléments dans le tableau d'origine après que chaque chiffre ait été trié.
Foire aux questions sur RadixSort
T1. Le tri Radix est-il préférable aux algorithmes de tri basés sur des comparaisons comme le tri rapide ?
Si nous avons un journal2n bits pour chaque chiffre, le temps d'exécution de Radix semble être meilleur que celui du tri rapide pour une large gamme de nombres saisis. Les facteurs constants cachés dans la notation asymptotique sont plus élevés car Radix Sort et Quick-Sort utilisent plus efficacement les caches matériels. De plus, le tri Radix utilise le tri par comptage comme sous-programme et le tri par comptage prend de l'espace supplémentaire pour trier les nombres.
Q2. Et si les éléments sont dans le varie de 1 à n 2 ?
- La limite inférieure de l'algorithme de tri basé sur la comparaison (Tri par fusion, Tri par tas, Tri rapide .. etc.) est Ω (nLogn), c'est-à-dire qu'ils ne peuvent pas faire mieux que nConnexion . Le tri par comptage est un algorithme de tri temporel linéaire qui trie en un temps O(n+k) lorsque les éléments sont compris entre 1 et k.
- Nous ne pouvons pas utiliser le tri par comptage car le tri par comptage prendra O(n2), ce qui est pire que les algorithmes de tri basés sur la comparaison. Pouvons-nous trier un tel tableau en temps linéaire ?
- Trier la base Est la réponse. L'idée de Radix Sort est d'effectuer un tri chiffre par chiffre en commençant par le chiffre le moins significatif jusqu'au chiffre le plus significatif. Le tri Radix utilise le tri par comptage comme sous-programme pour trier.