Você está na página 1de 4

RADIX SORT

Radix sort
Origem: Wikipdia, a enciclopdia livre.

Ir para: navegao, pesquisa O Radix sort um algoritmo de ordenao rpido e estvel que pode ser usado para ordenar itens que esto identificados por chaves nicas. Cada chave uma cadeia de caracteres ou nmero, e o radix sort ordena estas chaves numa qualquer ordem relacionada com a lexicografia. Na cincia da computao, radix sort uma algoritmo de ordenao que ordena inteiros processando dgitos individuais. J que os inteiros podem representar strings composta de caracteres (ex, nome ou datas) e pontos flutuantes especialmente formatados, radix sort no limitado somente a inteiros. Computadores na sua maioria internamente representam todos os tipo de dados por nmeros binrios, por isso processar os dgitos na forma de inteiros em grupos representados por dgitos binrios se torna mais conveniente. Existem duas classificaes do radix sorts que so elas: - Least significant digit (LSD Dgito menos significante) radix sorts; - Most significant digit (MSD Dgito mais significante) radix sorts. Radix sorts LSD comea do dgito menos significante at o mais significante. Radix sorts MSD trabalha no sentido contrrio. As representaes de inteiros que so processadas pelo algoritmo de ordenao so frequentemente chamadas de chaves, que podem existir por si prprias ou associadas a outros dados. Radix sorts LSD tipicamente usa a seguinte ordem de ordenao: chaves curtas vem antes de chaves longas, e chaves de mesmo tamanho so ordenadas lexicograficamente. Isso coincide com a ordem normal de representao dos inteiros, como a seqncia 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. Radix sorts MSD usa a ordem lexicogrfica, que adequada para ordenao de strings, assim como palavras, ou representaes inteiros fixa com tamanho fixo. A seqncia "b, c, d, e, f, g, h, i, j, ba" ser ordenada lexicograficamente assim "b, ba, c, d, e, f, g, h, i, j". Se a ordenao lexicogrfica usada para ordenar representaes de inteiros com tamanho varivel, ento a representao de nmeros inteiros de 1 a 10 ter a sada 1, 10, 2, 3, 4, 5, 6, 7, 8, 9, j que as chaves mais curtas so selecionadas primeiro pela esquerda e pulando para direita com espaos em branco para fazer as chaves tambm serem chaves longas para cumprir o proposito determinado pela ordenao. LSD um algoritmo de ordenao rpido e estvel, que pode ser usado para ordenar chaves curtas em ordem lexicogrfica. Chaves deve ser uma string de caracteres, ou numrica. O processo das chaves comea no dgito meno significante, o mais a direta, at o mais

significante, o mais a esquerda. A seqncia que cada digito processada pelo radix sort LSD contraria a seqncia que cada digito processada pelo radix sort MSD. O radix sort LSD opera na notao Big O, em O(nk), onde n o nmero de chaves, e o comprimento mdio da chave. Voc pode garantir esse desempenho para um comprimento varivel da chave agrupando todas as chaves que tem o mesmo comprimento juntas e separadamente agindo como um radix sort LSD em cada grupo de chaves para cada comprimento, do mais curto para o mais comprido, em ordem para evitar o processamento de um lista inteira de chaves em cada passo da ordenao. O algoritmo de ordenao radix foi originalmente usado para ordenar cartes perfurados em uma nmero grande de passos. Um algoritmo computador radix sort foi inventado em 1954 na MIT por Harold H. Seward. Em muitas aplicaes em que seja necessrio velocidade, o computador radix sort uma melhora nas ordenaes por comparao. O radix sort LSD tem se mostrado uma alternativa de alta performance em relao a algoritmos baseados na comparao (assim como heapsort e o mergesort) que requer comparaes (n log n), onde n o nmero de itens a serem ordenados. Algoritmos de ordenao baseados em comparaes no atingem mais que (n log n) em tempo de execuo, mas oferecem flexibilidade por ser aptos a ordenar respeitando formas mais complicadas de ordenao do que uma forma lexicogrfica, no entanto, essa habilidade de pouca importncia em vrias aplicaes prticas. Caractersticas Complexidade de Tempo: (nk). Complexidade de espao: (n + s). n = nmero de elementos. k = tamanho string. s = tamanho do alfabeto.

Implementaes
Cdigo em C#
private static void RadixSort(int[] a) { /* O radix */ int[] t = new int[a.Length]; // vetor auxiliar int r = 4;// tamanho dos bits int b = 32;//numero de bits de um inteiro int[] count = new int[1 << r]; int[] pref = new int[1 << r]; int groups = (int)Math.Ceiling((double)b / (double)r);//numero de grupos

int mask = (1 << r) - 1; for (int c = 0, shift = 0; c < groups; c++, shift += r) { for (int j = 0; j < count.Length; j++) count[j] = 0; for (int i = 0; i < a.Length; i++) count[(a[i] >> shift) & mask]++; pref[0] = 0; for (int i = 1; i < count.Length; i++) pref[i] = pref[i - 1] + count[i - 1]; for (int i = 0; i < a.Length; i++) t[pref[(a[i] >> shift) & mask]++] = a[i]; t.CopyTo(a, 0);

} }

Cdigo em Java
private static final int MAX_CHARS = 28; private static void radixSort (String [] v) { Queue queues [ ] = createQueues(); for ( int pos = maxSize( v ) - 1; pos >= 0; pos--) { for (int i = 0; i < v.length; i++) { int q = queueNo( v [ i ], pos ); queues [ q ].enqueue( v [ i ] ); } restore ( queues, v ); } } private static void restore ( Queue [ ] qs, String [ ] v) { int contv = 0; for ( int q = 0; q < qs.length; q++ ) while (! qs[ q ].empty( ) ) v [ contv++ ] = qs [ q ].dequeue( ); } private static Queue[] createQueues() { Queue[] result = new Queue [ MAX_CHARS ]; for (int i = 0; i < MAX_CHARS; i++) result [ i ] = new Queue(); return result ;

} private static int queueNo ( String string , int pos) { if (pos >= string.length ()) return 0; char ch = string .charAt(pos); if (ch >= A && ch <= Z) return ch - A + 1; else if (ch >= a && ch <= z) return ch - a + 1; else return 27; private static int maxSize(String [] v) int maiorValor = v[0]. length (); for (int i = 1; i < v.length; i++) if (maiorValor < v[i ]. length ()) maiorValor = v[i ]. length (); return maiorValor;

} {

Mesmo cdigo, em python


MAX_CHARS = 28 def radix_sort(lista): tamanho_maximo = max([len(palavra) for palavra in lista]) for pos in range(tamanho_maximo-1, -1, -1): baldes = [list() for x in range(MAX_CHARS)] for palavra in lista: balde = numero_do_balde(palavra, pos) baldes[balde] += [palavra] lista = sum(baldes, []) return lista def numero_do_balde(palavra, pos): if (pos >= len(palavra)): return 0 ch = palavra[pos] if (ch >= 'A' and ch <= 'Z'): return ord(ch) - ord('A') + 1 if (ch >= 'a' and ch <= 'z'): return ord(ch) - ord('a') + 1 return MAX_CHARS-1