logo

TechCodeview

Triedenie počítania – Príručky o štruktúre údajov a algoritmoch

Čo je triedenie počítania?

Počítanie Triediť je a nezaložené na porovnávaní triediaci algoritmus, ktorý funguje dobre, keď je obmedzený rozsah vstupných hodnôt. Je to obzvlášť efektívne, keď je rozsah vstupných hodnôt malý v porovnaní s počtom prvkov, ktoré sa majú triediť. Základná myšlienka Počítanie Triediť je počítať frekvencia každého odlišného prvku vo vstupnom poli a použiť tieto informácie na umiestnenie prvkov na ich správne zoradené pozície.

Ako funguje algoritmus triedenia počítania?

Krok 1 :



  • Zistite si maximálne prvok z daného poľa.

Nájdenie maximálneho prvku v inputArray[]

Krok 2:

  • Inicializovať a countArray[] dĺžky max+1 so všetkými prvkami ako 0 . Toto pole sa použije na ukladanie výskytov prvkov vstupného poľa.

Inicializovať countArray[]



Krok 3:

  • V countArray[] , uložte počet každého jedinečného prvku vstupného poľa v ich príslušných indexoch.
  • Napríklad: Počet prvkov 2 vo vstupnom poli je 2. Takže skladujte 2 pri indexe 2 v countArray[] . Podobne aj počet prvkov 5 vo vstupnom poli je 1 , teda obchod 1 pri indexe 5 v countArray[] .

Udržujte počet každého prvku v countArray[]

Krok 4:



  • Uložte kumulatívna suma alebo súčet predpony z prvkov countArray[] vykonávaním countArray[i] = countArray[i – 1] + countArray[i]. To pomôže umiestniť prvky vstupného poľa na správny index vo výstupnom poli.

Uložte kumulatívny súčet do countArray[]

Krok 5:

  • Iterujte od konca vstupného poľa a pretože prechádzanie vstupným poľom od konca zachováva poradie rovnakých prvkov, čo nakoniec robí tento triediaci algoritmus stabilný .
  • Aktualizovať outputArray[ countArray[ inputArray[i] ] – 1] = inputArray[i] .
  • Tiež aktualizujte countArray[ inputArray[i] ] = countArray[ inputArray[i] ] – –.

5

Krok 6: Pre i = 6 ,

rozhranie vs abstraktná trieda

Aktualizovať outputArray[ countArray[ inputArray[6] ] – 1] = inputArray[6]
Tiež aktualizujte countArray[ inputArray[6] ] = countArray[ inputArray[6] ]- –

Umiestnenie inputArray[6] na správnu pozíciu vo outputArray[]

Krok 7: Pre i = 5 ,

Aktualizovať outputArray[ countArray[ inputArray[5] ] – 1] = inputArray[5]
Tiež aktualizujte countArray[ inputArray[5] ] = countArray[ inputArray[5] ]- –

Umiestnenie inputArray[5] na správnu pozíciu vo outputArray[]

Krok 8: Pre i = 4 ,

Aktualizovať outputArray[ countArray[ inputArray[4] ] – 1] = inputArray[4]
Tiež aktualizujte countArray[ inputArray[4] ] = countArray[ inputArray[4] ]- –

Umiestnenie inputArray[4] na správnu pozíciu vo outputArray[]

Krok 9: Pre i = 3 ,

Aktualizovať outputArray[ countArray[ inputArray[3] ] – 1] = inputArray[3]
Tiež aktualizujte countArray[ inputArray[3] ] = countArray[ inputArray[3] ]- –

Umiestnenie inputArray[3] na správnu pozíciu vo outputArray[]

Krok 10: Pre i = 2 ,

Aktualizovať outputArray[ countArray[ inputArray[2] ] – 1] = inputArray[2]
Tiež aktualizujte countArray[ inputArray[2] ] = countArray[ inputArray[2] ]- –

Umiestnenie inputArray[2] na správnu pozíciu vo outputArray[]

Krok 11: Pre i = 1 ,

Aktualizovať outputArray[ countArray[ inputArray[1] ] – 1] = inputArray[1]
Tiež aktualizujte countArray[ inputArray[1] ] = countArray[ inputArray[1] ]- –

Umiestnenie inputArray[1] na správnu pozíciu vo outputArray[]

Krok 12: Pre i = 0,

Aktualizovať outputArray[ countArray[ inputArray[0] ] – 1] = inputArray[0]
Tiež aktualizujte countArray[ inputArray[0] ] = countArray[ inputArray[0] ]- –

Umiestnenie inputArray[0] na správnu pozíciu vo outputArray[]

Algoritmus triedenia počítania:

  • Deklarujte pomocné pole countArray[] veľkosti max(inputArray[])+1 a inicializujte ho pomocou 0 .
  • Traverzové pole inputArray[] a mapovať každý prvok inputArray[] ako index countArray[] pole, t.j. spustiť countArray[inputArray[i]]++ pre 0 <= i < N .
  • Vypočítajte súčet prefixov pre každý index poľa inputArray [].
  • Vytvorte pole outputArray[] veľkosti N .
  • Traverzové pole inputArray[] od konca a aktualizovať outputArray[ countArray[ inputArray[i] ] – 1] = inputArray[i] . Tiež aktualizujte countArray[ inputArray[i] ] = countArray[ inputArray[i] ]- – .

Nižšie je uvedená implementácia vyššie uvedeného algoritmu:

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--) { vystupPole[pocetPole[vstupnePole[i]] - 1] = vstupnePole[i]; countArray[inputArray[i]]--; } return vystupne pole; } public static void main(String[] argumenty) { int[] inputArray = {4, 3, 12, 1, 5, 5, 3, 9}; int[] vystupnePole = pocetSort(vstupnePole); for (int i = 0; i System.out.print(outputArray[i] + ' '); } } }> 

>

>

C#




using> System;> using> System.Collections.Generic;> class> GFG> {> >static> List<>int>>CountSort(Zoznam<>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 = nový zoznam (nový int[M + 1]); // Mapovanie každého prvku inputArray[] ako indexu // poľa countArray[] pre (int i = 0; i countArray[inputArray[i]]++; // Výpočet súčtu prefixov pri každom indexe // poľa countArray [] pre (int i = 1; i<= M; i++) countArray[i] += countArray[i - 1]; // Creating outputArray[] from the countArray[] array List outputArray = nový zoznam (nové int[N]); for (int i = N - 1; i>= 0; i--) { outputArray[countArray[inputArray[i]] - 1] = inputArray[i]; countArray[inputArray[i]]--; } return vystupne pole; } // Kód ovládača static void Main() { // Zoznam vstupných polí inputArray = nový zoznam {4, 3, 12, 1, 5, 5, 3, 9}; // Výstupné pole Zoznam outputPole = CountSort(inputArray); for (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--) { vystupPole[pocetPole[vstupnePole[i]] - 1] = vstupnePole[i]; countArray[inputArray[i]]--; } return vystupne pole; } // Kód ovládača const inputArray = [4, 3, 12, 1, 5, 5, 3, 9]; // Triedenie vstupného poľa const outputArray = countSort(inputArray); // Tlač zoradeného poľa console.log(outputArray.join(' ')); //Tento kód prispel Utkarsh>

kľúč na vloženie notebooku 

>

>

C++14




#include> using> namespace> std;> vector<>int>>countSort(vektor<>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); // Mapovanie každého prvku inputArray[] ako indexu // poľa countArray[] pre (int i = 0; i countArray[inputArray[i]]++; // Výpočet súčtu prefixov pri každom indexe // poľa countArray [] pre (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]]--; } return vystupne pole; } // Kód ovládača int main() { // Vstupný vektor poľa inputArray = { 4, 3, 12, 1, 5, 5, 3, 9 }; // Výstup vektora poľa outputArray = countSort(inputArray); for (int i = 0; i cout<< outputArray[i] << ' '; return 0; }> 

>

>

Python3




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>=>' '>)> 

>

>

Výkon 

1 3 3 4 5 5 9 12>

Analýza zložitosti triedenia počítania:

  • Časová zložitosť : O(N+M), kde N a M sú veľkosti inputArray[] a countArray[] resp.
    • Najhorší prípad: O(N+M).
    • Priemerný prípad: O(N+M).
    • Najlepší prípad: O(N+M).
  • Pomocný priestor: O(N+M), kde N a M sú zaberaný priestor outputArray[] a countArray[] resp.

Výhoda triedenia počítania:

  • Triedenie počítania vo všeobecnosti funguje rýchlejšie ako všetky algoritmy triedenia založené na porovnávaní, ako je zlučovacie triedenie a rýchle triedenie, ak je rozsah vstupu rádovo podľa počtu vstupov.
  • Počítanie triedenia je jednoduché na kódovanie
  • Druh počítania je a stabilný algoritmus .

Nevýhoda triedenia počítania:

  • Triedenie počítania nefunguje pri desatinných hodnotách.
  • Triedenie počítania je neefektívne, ak je rozsah triedených hodnôt veľmi veľký.
  • Počítanie zoradiť nie je Triedenie na mieste algoritmus, Využíva extra priestor na triedenie prvkov poľa.