logo

TechCodeview

Counting Sort - Tutorials d'estructures de dades i algorismes

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.

Trobar l'element màxim a inputArray[]

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.

Inicialitza countArray[]



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[] .

Mantenir el recompte de cada element a 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.

Emmagatzema la suma acumulada a countArray[]

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] ] – -.

5

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] ]- –

Col·locant inputArray[6] a la seva posició correcta a outputArray[]

Pas 7: Per i = 5 ,

Actualització outputArray[ countArray[ inputArray[5] ] – 1] = inputArray[5]
També, actualitzar countArray[ inputArray[5] ] = countArray[ inputArray[5] ]- –

Col·locant inputArray[5] a la seva posició correcta a outputArray[]

Pas 8: Per i = 4 ,

Actualització outputArray[ countArray[ inputArray[4] ] – 1] = inputArray[4]
També, actualitzar countArray[ inputArray[4] ] = countArray[ inputArray[4] ]- –

Col·locant inputArray[4] a la seva posició correcta a outputArray[]

Pas 9: Per i = 3 ,

Actualització outputArray[ countArray[ inputArray[3] ] – 1] = inputArray[3]
També, actualitzar countArray[ inputArray[3] ] = countArray[ inputArray[3] ]- –

Col·locant inputArray[3] a la seva posició correcta a outputArray[]

Pas 10: Per i = 2 ,

Actualització outputArray[ countArray[ inputArray[2] ] – 1] = inputArray[2]
També, actualitzar countArray[ inputArray[2] ] = countArray[ inputArray[2] ]- –

Col·locant inputArray[2] a la posició correcta a outputArray[]

Pas 11: Per i = 1 ,

Actualització outputArray[ countArray[ inputArray[1] ] – 1] = inputArray[1]
També, actualitzar countArray[ inputArray[1] ] = countArray[ inputArray[1] ]- –

Col·locant inputArray[1] a la seva posició correcta a outputArray[]

Pas 12: Per i = 0,

Actualització outputArray[ countArray[ inputArray[0] ] – 1] = inputArray[0]
També, actualitzar countArray[ inputArray[0] ] = countArray[ inputArray[0] ]- –

Col·locant inputArray[0] a la seva posició correcta a outputArray[]

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 countArray = llista nova (nou int[M + 1]); // 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 the countArray[] array List outputArray = llista nova (nou int[N]); for (int i = N - 1; i>= 0; i--) { outputArray[countArray[inputArray[i]] - 1] = inputArray[i]; countArray[inputArray[i]]--; } retornar outputArray; } // Codi del controlador static void Main() { // Llista de matrius d'entrada inputArray = llista nova {4, 3, 12, 1, 5, 5, 3, 9 }; // Llista de matrius de sortida outputArray = CountSort (inputArray); per a (int i = 0; i Console.Write(outputArray[i] + ' '); Console.WriteLine(); } }> 

>

>

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>=>' '>)>  
  
 
    
 
>
 
    
 
>
 
  Sortida  
 
1 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.
    •