Què és Counting Sort?
Ordenació de recompte és un no basat en la comparació algorisme d'ordenació que funciona bé quan hi ha un rang limitat de valors d'entrada. És especialment eficient quan el rang de valors d'entrada és petit en comparació amb el nombre d'elements que s'han d'ordenar. La idea bàsica darrere Ordenació de recompte és comptar el freqüència de cada element diferent de la matriu d'entrada i utilitzeu aquesta informació per col·locar els elements en les seves posicions ordenades correctament.
Com funciona l'algoritme d'ordenació de recompte?
Pas 1 :
- Descobreix el màxim element de la matriu donada.
Pas 2:
- Inicialitzar a countArray[] de longitud màxim+1 amb tots els elements com 0 . Aquesta matriu s'utilitzarà per emmagatzemar les ocurrències dels elements de la matriu d'entrada.
Pas 3:
- En el countArray[] , emmagatzema el recompte de cada element únic de la matriu d'entrada als seus índexs respectius.
- Per exemple: El recompte de l'element 2 a la matriu d'entrada és 2. Per tant, emmagatzema 2 a l'índex 2 en el countArray[] . De la mateixa manera, el recompte d'elements 5 a la matriu d'entrada és 1 , per tant, botiga 1 a l'índex 5 en el countArray[] .
Pas 4:
- Emmagatzemar el suma acumulada o suma del prefix dels elements de la countArray[] fent countArray[i] = countArray[i – 1] + countArray[i]. Això ajudarà a col·locar els elements de la matriu d'entrada a l'índex correcte de la matriu de sortida.
Pas 5:
- Itereu des del final de la matriu d'entrada i perquè recórrer la matriu d'entrada des del final conserva l'ordre dels elements iguals, cosa que finalment fa que aquest algorisme d'ordenació estable .
- Actualització outputArray[ countArray[ inputArray[i] ] – 1] = inputArray[i] .
- També, actualitzar countArray[ inputArray[i] ] = countArray[ inputArray[i] ] – -.
Pas 6: Per i = 6 ,
l'actriu zeenat aman
Actualització outputArray[ countArray[ inputArray[6] ] – 1] = inputArray[6]
També, actualitzar countArray[ inputArray[6] ] = countArray[ inputArray[6] ]- –
Pas 7: Per i = 5 ,
Actualització outputArray[ countArray[ inputArray[5] ] – 1] = inputArray[5]
També, actualitzar countArray[ inputArray[5] ] = countArray[ inputArray[5] ]- –
Pas 8: Per i = 4 ,
Actualització outputArray[ countArray[ inputArray[4] ] – 1] = inputArray[4]
També, actualitzar countArray[ inputArray[4] ] = countArray[ inputArray[4] ]- –
Pas 9: Per i = 3 ,
Actualització outputArray[ countArray[ inputArray[3] ] – 1] = inputArray[3]
També, actualitzar countArray[ inputArray[3] ] = countArray[ inputArray[3] ]- –
Pas 10: Per i = 2 ,
Actualització outputArray[ countArray[ inputArray[2] ] – 1] = inputArray[2]
També, actualitzar countArray[ inputArray[2] ] = countArray[ inputArray[2] ]- –
Pas 11: Per i = 1 ,
Actualització outputArray[ countArray[ inputArray[1] ] – 1] = inputArray[1]
També, actualitzar countArray[ inputArray[1] ] = countArray[ inputArray[1] ]- –
Pas 12: Per i = 0,
Actualització outputArray[ countArray[ inputArray[0] ] – 1] = inputArray[0]
També, actualitzar countArray[ inputArray[0] ] = countArray[ inputArray[0] ]- –
Algoritme d'ordenació de recompte:
- Declarar una matriu auxiliar countArray[] de mida màx(inputArray[])+1 i inicialitzar-lo amb 0 .
- Matriu transversal inputArray[] i mapeja cada element de inputArray[] com a índex de countArray[] array, és a dir, executar countArray[inputArray[i]]++ per 0 <= i < N .
- Calcula la suma del prefix a cada índex de la matriu inputArray [].
- Crea una matriu outputArray[] de mida N .
- Matriu transversal inputArray[] des del final i actualització outputArray[ countArray[ inputArray[i] ] – 1] = inputArray[i] . També, actualitzar countArray[ inputArray[i] ] = countArray[ inputArray[i] ]- – .
A continuació es mostra la implementació de l'algorisme anterior:
Java
import> java.util.Arrays;> public> class> CountSort {> > public> static> int> [] countSort(> int> [] inputArray) {> > int> N = inputArray.length;> > int> M => 0> ;> > for> (> int> i => 0> ; i M = Math.max(M, inputArray[i]); } int[] countArray = new int[M + 1]; for (int i = 0; i countArray[inputArray[i]]++; } for (int i = 1; i <= M; i++) { countArray[i] += countArray[i - 1]; } int[] outputArray = new int[N]; for (int i = N - 1; i>= 0; i--) { outputArray[countArray[inputArray[i]] - 1] = inputArray[i]; countArray[inputArray[i]]--; } retornar outputArray; } public static void main(String[] args) { int[] inputArray = {4, 3, 12, 1, 5, 5, 3, 9}; int[] outputArray = countSort(inputArray); per (int i = 0; i System.out.print(outputArray[i] + ' '); } } }> |
>
>
C#
using> System;> using> System.Collections.Generic;> class> GFG> {> > static> List<> int> >CountSort (Llista<> int> >inputArray)> > {> > int> N = inputArray.Count;> > // Finding the maximum element of the array inputArray[].> > int> M = 0;> > for> (> int> i = 0; i M = Math.Max(M, inputArray[i]); // Initializing countArray[] with 0 List |
>
>
Javascript
function> countSort(inputArray) {> > const N = inputArray.length;> > // Finding the maximum element of inputArray> > let M = 0;> > for> (let i = 0; i M = Math.max(M, inputArray[i]); } // Initializing countArray with 0 const countArray = new Array(M + 1).fill(0); // Mapping each element of inputArray as an index of countArray for (let i = 0; i countArray[inputArray[i]]++; } // Calculating prefix sum at every index of countArray for (let i = 1; i <= M; i++) { countArray[i] += countArray[i - 1]; } // Creating outputArray from countArray const outputArray = new Array(N); for (let i = N - 1; i>= 0; i--) { outputArray[countArray[inputArray[i]] - 1] = inputArray[i]; countArray[inputArray[i]]--; } retornar outputArray; } // Codi del controlador const inputArray = [4, 3, 12, 1, 5, 5, 3, 9]; // Ordenant la matriu d'entrada const outputArray = countSort(inputArray); // Imprimeix la matriu ordenada console.log(outputArray.join(' ')); //Aquest codi és aportat per Utkarsh>>> |
ordenació de selecció de java
>
#include>
using>
namespace>
std;>
vector<>
int>
>countSort (vector<>
int>
>& inputArray)>
{>
>
int>
N = inputArray.size();>
>
// Finding the maximum element of array inputArray[].>
>
int>
M = 0;>
>
for>
(>
int>
i = 0; i M = max(M, inputArray[i]); // Initializing countArray[] with 0 vector
countArray (M + 1, 0); // Mapeig de cada element de inputArray[] com a índex // de la matriu countArray[] per a (int i = 0; i countArray[inputArray[i]]++; // Càlcul de la suma del prefix a cada índex // de la matriu countArray [] per a (int i = 1; i<= M; i++) countArray[i] += countArray[i - 1]; // Creating outputArray[] from countArray[] array vector outputArray(N); for (int i = N - 1; i>= 0; i--) { outputArray[countArray[inputArray[i]] - 1] = inputArray[i]; countArray[inputArray[i]]--; } retornar outputArray; } // Codi del controlador int main() { // Vector de matriu d'entrada inputArray = { 4, 3, 12, 1, 5, 5, 3, 9 }; // Vector de matriu de sortida outputArray = countSort (inputArray); per (int i = 0; i cout<< outputArray[i] << ' '; return 0; }> >>Python 3
def>
count_sort(input_array):>
>
# Finding the maximum element of input_array.>
>
M>
=>
max>
(input_array)>
>
# Initializing count_array with 0>
>
count_array>
=>
[>
0>
]>
*>
(M>
+>
1>
)>
>
# Mapping each element of input_array as an index of count_array>
>
for>
num>
in>
input_array:>
>
count_array[num]>
+>
=>
1>
>
# Calculating prefix sum at every index of count_array>
>
for>
i>
in>
range>
(>
1>
, M>
+>
1>
):>
>
count_array[i]>
+>
=>
count_array[i>
->
1>
]>
>
# Creating output_array from count_array>
>
output_array>
=>
[>
0>
]>
*>
len>
(input_array)>
>
for>
i>
in>
range>
(>
len>
(input_array)>
->
1>
,>
->
1>
,>
->
1>
):>
>
output_array[count_array[input_array[i]]>
->
1>
]>
=>
input_array[i]>
>
count_array[input_array[i]]>
->
=>
1>
>
return>
output_array>
# Driver code>
if>
__name__>
=>
=>
'__main__'>
:>
>
# Input array>
>
input_array>
=>
[>
4>
,>
3>
,>
12>
,>
1>
,>
5>
,>
5>
,>
3>
,>
9>
]>
>
# Output array>
>
output_array>
=>
count_sort(input_array)>
>
for>
num>
in>
output_array:>
>
print>
(num, end>
=>
' '>
)>
>>Sortida1 3 3 4 5 5 9 12>Anàlisi de complexitat de l'ordenació de recompte:
- Complexitat temporal : O(N+M), on N i M tenen la mida de inputArray[] i countArray[] respectivament.
- El pitjor dels casos: O(N+M).
- Cas mitjà: O(N+M).
- Millor cas: O(N+M).
- Espai auxiliar: O(N+M), on N i M són l'espai ocupat outputArray[] i countArray[] respectivament.
Avantatge de l'ordenació de recompte:
- L'ordenació de recompte en general funciona més ràpid que tots els algorismes d'ordenació basats en comparacions, com ara l'ordenació per fusió i l'ordenació ràpida, si l'interval d'entrada és de l'ordre del nombre d'entrada.
- L'ordenació de recompte és fàcil de codificar
- L'ordenació de recompte és a algorisme estable .
Desavantatge de l'ordenació de recompte:
- L'ordenació de recompte no funciona amb valors decimals.
- L'ordenació de recompte és ineficient si l'interval de valors a ordenar és molt gran.
- L'ordenació de recompte no és una Classificació in situ algorisme, utilitza espai addicional per ordenar els elements de la matriu.