ALG 09. Radix sort (přihrádkové řazení) Counting sort. Přehled asymptotických rychlostí jednotlivých řazení. Ilustrační experiment řazení

Transkript

1 ALG Radix sort (přihrádkové řazení) Counting sort Přehled asymptotických rychlostí jednotlivých řazení Ilustrační experiment řazení

2 Radix sort Neseřazeno Řaď podle. znaku Cbb DaD adb DCa CCC add DDb adc bbc bab B a b C D DCa Cbb CCC Cba adb adc DDb bbc bab acb DaD add DbD DbD Cba acb Staré pořadí Nové pořadí

3 Radix sort Seřazeno od. znaku Řaď podle. znaku DCa Cba Cbb B _ a b C D_ adb DDb bab acb CCC bab DaD Cba Cbb bbc DbD DCa acb CCC adb DDb adc add adc bbc DaD add DbD

4 Radix sort Seřazeno od. znaku Řaď podle. znaku bab DaD Cba Cbb bbc DbD DCa acb CCC B a b C D acb adb adc add bab Cba bbc Cbb CCC DaD DbD DCa DDb adb DDb adc add Seřazeno!

5 Implementace radix sortu Neseřazeno Seřazeno dle. znaku Pomocná pole indexů registrují nové pořadí. Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb B a DCa Cba b Cbb adb DDb bab acb Příklad C CCC adc bbc D DaD add DbD zač. & konec a b C D Příklad další

6 Implementace radix sortu Neseřazeno Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb Jedno pole pro všechny seznamy a b C D z k Ukázka seznamu pro 'b' Pole ukazatelů na začátek a konec seznamu pro každý znak Aktuálně obě pole přesně registrují stav po seřazení podle. znaku. Radix sort lze provést bez přesouvání původních dat, pouze manipulací s uvedenými celočíselnými poli, která obsahují veškerou informaci o aktuálním stavu řazení.

7 Implementace radix sortu Neseřazeno Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb Stav po seřazení podle. znaku. a b C D z k z k Ukázka seznamů pro 'b' Stav po seřazení podle. znaku = seřazeno. a b C D

8 Implementace radix sortu Neseřazeno Stav po seřazení podle. znaku = seřazeno. Stačí vypsat data v pořadí daném seznamy: a b C D Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb a b C D z k acb adb adc add bab bbc Cba Cbb CCC DaD DbD DCa DDb

9 Od seřazení podle. znaku k seřazení podle. znaku Pole obsahují uspořádání podle. znaku. a b C D z k a b C D z k Pole budou obsahovat uspořádání podle. znaku Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb d d Aktualizace polí z, k, d proběhne tak, že naplníme nová pole z, k, d, která nakonec zkopírujeme zpět do z, k, d. Implementačně ovšem není třeba cokoli kopírovat, stačí záměna referencí (ukazatelů, pointerů) na tato pole.

10 Od seřazení podle. znaku k seřazení podle. znaku Usp. dle. zn. a b C D z k a b C D z k z k z k z k z k z k z k Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb d d d d d d d d

11 Od seřazení podle. znaku k seřazení podle. znaku Usp. dle. zn. a b C D z k a b C D z k z k z k z k z k z k z k Cbb DaD adb DCa CCC add DDb adc bbc bab DbD Cba acb d d d d d d d d Hotovo

12 Implementace radix sortu void radix_sort( String [] a ) { int charcount =...; // number of chars used (^?) int [] z = new int [charcount]; int [] k = new int [charcount]; int [] z = new int [charcount]; int [] k = new int [charcount]; int [] d = new int [a.length]; int [] d = new int [a.length]; int [] aux; initstep( a, z, k, d ); // st pass with last char } for( int p = a[].length()-; p >= ; p-- ) { radixstep( a, p, z, k, d, z, k, d ); // do the job aux = z; z = z; z = aux; // just swap arrays aux = k; k = k; k = aux; // dtto aux = d; d = d; d = aux; // dtto } output( a, z, k, d ); // print sorted array

13 Implementace radix sortu void initstep( String[] a, int [] z, int [] k, int [] d ){ int pos = a[].length()-; // last char in string int c; // char as array index for Radix sort for( int i = ; i < z.length; i++ ) // init arrays z[i] = k[i] = -; // empty for( int i = ; i < a.length; i++ ){ // all last chars c = (int) a[i].charat(pos); // char to index if( z[c] == - ) k[c]= z[c] = i; // start new list else { d[k[c]] = i; // extend existing list k[c] = i; } } } Řetězce různé délky nutno uvést na stejnou délku připojením "nevýznamných znaků", např. mezer. V ukázkovém kódu všechny indexy polí začínají, v obrázcích začínají.

14 Implementace radix sortu void radixstep( String [] a, int pos, int [] z, int [] k, int [] d, int [] z, int [] k, int [] d ){ int j; // index traverses old lists int c; // char as array index for Radix sort for( int i = ; i < z.length; i++ ) // init arrays z[i] = k[i] = -; // for( int i = ; i < z.length; i++ ) // for all used chars if (z[i]!= -) { // unempty list j = z[i]; while( true ){ // scan the list c = (int) a[j].charat(pos); // char to index if( z[c] == - ) k[c]= z[c] = j; // start new list else { d[k[c]] = j; // extend existing list k[c] = j; } if( j == k[i] ) break; j = d[j]; // next string index } } }

15 Radix sort d znaků... d cyklů Shrnutí cyklus... celkem... (n) operací (d n) operací d << n... (n) operací Radix sort nemění pořadí stejných hodnot Asymptotická složitost Radix sortu je Pro malé konstantní d lze psát (n*d) (n) Je to stabilní řazení

16 Counting sort vstup vstup.length == N cetnost cetnost.length == k k = max(vstup) - min(vstup) + vystup vstup.length == N

17 Counting sort Krok Vynulování pole četností Jeden průchod vstupním polem Naplnění pole četností

18 Counting sort Krok jeden průchod Pole četností mění svou roli Úprava pole četností for( int i = dmez+; i <= hmez; i++ ) cetnost[i] += cetnost[i-] Prvek cetnost[ j ] obsahuje pozici posledního prvku s hodnotou j v budoucím výstupním poli.

19 Counting sort Krok i == N for( int i = N; i > ; i-- ) { vystup[cetnost[vstup[i]]] = vstup[i]; cetnost[vstup[i]]--; } i ==

20 Counting sort Krok i == N- for( int i = N; i > ; i-- ) { vystup[cetnost[vstup[i]]] = vstup[i]; cetnost[vstup[i]]--; } i ==

21 Counting sort Krok i == N- for( int i = N; i > ; i-- ) { vystup[cetnost[vstup[i]]] = vstup[i]; cetnost[vstup[i]]--; } i == atd...

22 Counting sort Krok i == for( int i = N; i > ; i-- ) { vystup[cetnost[vstup[i]]] = vstup[i]; cetnost[vstup[i]]--; } i == atd...

23 Orientační přehled vlastností řadících algoritmů Velikost pole n Nejhorší případ Nejlepší případ "typický", "běžný" případ Stabilní Všeobecné Selection sort (n ) (n ) (n ) Ne Ano Insertion sort (n ) (n) (n ) Ano Ano Bubble sort (n ) (n ) (n ) Ano Ano Quick sort (n ) (n log(n)) (n log(n)) Ne Ano Merge sort (n log(n)) (n log(n)) (n log(n)) Ano Ano Heap sort (n log(n)) O(n log(n)) (n log(n)) Ne Ano Radix sort (n) (n) (n) Ano Ne Counting sort (n) (n) (n) Ano Ne

24 Ilustrační experiment řazení Prostředí Intel(R). GHz, Microsoft Windows XP SP, jdk.._. Organizace Použita řazení, v nichž se prvky (double) navzájem porovnávají. Kódy převzaty z přednášky (žádné další triky). Řazení v jednotlivých velikostech prováděna na stejných datech. Pole náhodně zamíchána generátorem pseudonáhodných čísel s rovnoměrným rozložením. Výsledky průměrovány přes větší počet běhů. Závěr Neexistuje jedno univerzální řazení, které by bylo optimální za všech okolností. Hraje roli stabilita, velikost dat i stupeň předběžného seřazení dat.

25 Ilustrační experiment řazení Délka pole % seř. % % % % % % % % % % % % Doba běhu v milisekundách, není-li uvedeno jinak Sort Select Insert Bubble Quick Merge Heap min min min min. min. min Seřazená část pole. Pole je nejprve seřazeno, pak náhodně vybrané prvky změní libovolně hodnotu.

26 Ilustrační experiment řazení Délka pole % seř. % % % % % % % % % % % % Koeficient zpomalení ( > ) vůči Quick sortu pro danou velikost dat a předběžné seřazení Sort Select Insert Bubble Quick Merge Heap Nejrychlejší Nejpomalejší Select a Bubble sorty nesoutěží. Stabilní

27 Ilustrační experiment řazení Délka pole % seř. % % % % % % % % % % % % Koeficient zpomalení ( > ) při srovnání rychlosti řazení neseřazeného a částečně seřazeného pole Sort Select Insert Bubble Quick Merge Heap Stabilní