UNIVERSIDADE LUTERANA DO BRASIL

CENTRO DE CIÊNCIAS EXATAS E NATURAIS

CURSO DE SISTEMAS DE INFORMAÇÃO

ORDENAÇÃO DE DADOS POR DISTRIBUIÇÃO DE CHAVES

IGOR CASA NOVA DOS SANTOS

UÍLSON ZANETTI GOMES
MAURICIO VOLKWEIS ASTIAZARA
HENRIQUE OLIVEIRA

Estrutura de Dados II
Torres, Abril de 2002
 Sumário

Lista de Tabelas.....................................................................................................................................3
Resumo..................................................................................................................................................4
Introdução...............................................................................................................................................5
1 Origem.................................................................................................................................................6
2 Base....................................................................................................................................................6
3 Algoritmo.............................................................................................................................................7
4 Vantagens e Desvantagens...............................................................................................................10
Conclusão.............................................................................................................................................12
Bibliografia............................................................................................................................................13

2
 Lista de Tabelas

Lista de Tabelas.....................................................................................................................................3
Resumo..................................................................................................................................................4
Introdução...............................................................................................................................................5
1 Origem.................................................................................................................................................6
2 Base....................................................................................................................................................6
3 Algoritmo.............................................................................................................................................7
4 Vantagens e Desvantagens...............................................................................................................10
Conclusão.............................................................................................................................................12
Bibliografia............................................................................................................................................13

3
 Resumo

Até agora conhecíamos métodos variados de ordenação como o Bubble Sort, Shake
Sort ou o Quick Sort, que na verdade percorriam o vetor, comparavam dois números e
ordenavam de acordo com as especificações do algoritmo. Nosso principal objetivo nesse
trabalho é apresentar um método diferenciado conhecido como algoritmo de ordenação de
dados por distribuição de chaves, um algoritmo antigo mas até hoje usado. A principal
finalidade desse algoritmo é dividir o conteúdo de uma posição do vetor em dígitos,
ordenando cada dígito separadamente começando pelas unidades. Pode até parecer um
método complicado, mas não é.
Por ser usado desde a época dos cartões perfurados, sua codificação e lógica são bem
simples de entender. Para facilitar essa compreensão nós procuramos ilustrar o funcionamento
desse método com um exemplo explicativo, além de citarmos seus principais princípios e
fundamentos.

Abstract

Until then we know sort methods like Bubble Sort, Shake Sort and Quick Sort, that
scan array, compare two numbers and sort then as algorithm especification. Our objective in
this research is to present a different method, called Data Sort by Key Distribution, a old
algorithm but yet used. The algorithm goal is to divide a content of array position in digits,
sorting each digit separately beginning by units. Can seem complex, but it’s not.
Because it is usually since punched cards time, its code and lógic are simple to
understand. To make easy understanding we try to illustrate functioning this method with a
example, and explain its main principles and fundamentals.

4
 Introdução

Um dos mais antigos e triviais problemas é a classificação de dados, objetos, valores.

Para resolver esse problema surgiram diversas soluções. Diferentes algoritmos, com
características particulares, cada um tentando obter o máximo de eficiência.
Nesta busca pelo título de “melhor algoritmo de ordenação de dados” não há um
vencedor, mas sim, algoritmos que apresentam um melhor desempenho dependendo da
situação em que são empregados e com que diretrizes, como por exemplo:
• Economizar o uso da memória ou do processamento?
• Um código menor em tamanho ou um mais rápido?
• Os dados a serem ordenados são altamente variáveis e o algoritmo deve ser o
mais genérico possível ou o sistema implica em uma particularidade nos dados
possibilitando a aplicação de um algoritmo otimizado?
O analista deve considerar estas e outras questões e tomar uma decisão com base nos
algoritmos de que tem conhecimento e completa compreensão de funcionamento. Com esse
trabalho podemos colocar mais uma opção para o analista: a ordenação de dados por
distribuição de chaves.

5
1 Origem
O algoritmo de ordenação de dados por distribuição de chaves também é conhecido
pelos nomes radixsort, algoritmo das raízes e indexação direta. Esse método foi desenvolvido
inicialmente para as máquinas de ordenação de cartões perfurados. Essa máquinas eram
usadas em cálculos de dados, como por exemplo, o censo populacional. Depois os cartões
perfurados passaram a ser usados como entrada de dados em computadores digitais, mas se
tornaram obsoletos com o advento dos meios magnéticos. Mesmo assim o método de
ordenação de dados por distribuição de chaves sobreviveu devido à sua eficiência.

2 Base
Ao contrário dos outros métodos, que comparam as chaves (números que servem de
base para a ordenação) e realizam trocas, o método por distribuição de chaves se baseia em
dois princípios simples que são característicos no nosso sistema numérico arábico.

2.1 Princípio da Limitação de Dígitos

O número de dígitos (caracteres) usados em uma base numérica é limitado, mas a

quantidade de números que podem representar quando combinados é infinita.

Tabela 1: Dígitos usados nas bases numéricas

Base Numérica Dígitos (Caracteres) Intervalo de Valores

Decimal 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 - infinito à + infinito
Binária 0, 1 - infinito à + infinito
Hexadecimal 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, - infinito à + infinito
F

Com base nesses conhecimentos, o algoritmo de ordenação por distribuição de

chaves parte do princípio de já “conhecer” a ordenação correta dos dígitos, que como foi dito,
são uma quantidade limitada e conhecida. Assim ele “consegue” ordenar um vetor onde as
chaves de ordenação tenham apenas um dígito.

2.2 Princípio do Valor pela Posição

Cada dígito em um sistema numérico tem um valor intrínseco, que é considerado

unidade. Mas quando combinamos mais de um dígito para representar um valor maior que um
único não conseguiria representar, o valor de cada dígito muda de acordo com a posição em
que ocupa no número.
Vamos relembrar o sistema de representação dos valores dos dígitos de acordo com a
posição. Em um número na base B, cada dígito representa seu valor unitário vezes B elevado
na sua posição-1, partindo da direita para a esquerda, como mostra a tabela:

Tabela 2: O valor que cada dígito representa depende da sua posição

Base Valor do Dígito na Posição

N 3 2 1
B Dígito * B(N – 1) Dígito * B2 Dígito * B1 Dígito * 1

6
Decimal Dígito * 10(N – 1) Dígito * 100 Dígito * 10 Dígito * 1
Binária Dígito * 2(N – 1) Dígito * 4 Dígito * 2 Dígito * 1
Hexadecimal Dígito * 16(N – 1) Dígito * 256 Dígito * 16 Dígito * 1

Por exemplo, no número 235 em decimal, o 2 tem valor 200, o 3 tem valor 30 e o 5 o
próprio valor de 5 unidades. Desta forma 235 representa o valor da soma 200+30+5.
Sendo assim, os dígitos à direita de um dígito D são menos significativos que ele. Já
os dígitos à esquerda de D são mais significativos que ele (lembrando que a contagem da
posição de um dígito inicia na direita e segue para a esquerda). Isso ocorre independente do
valor dos dígitos em sua forma unitária. O termo significativo quer dizer valor.
Desta forma, em um número formado por dígitos desconhecidos, como XYZ, em
uma base desconhecida, pode se ter a certeza que X>Y>Z. Como foi dito, isso independe dos
valores unitários de cada um dos dígitos. Mesmo sendo 1<2<3, no número 123, de acordo
com o valor posicional, 1>2>3, pois 1 representa uma centena, dois representa duas dezenas e
três, três unidades, na base decimal.

2.3 Aplicando os Dois Princípios

Para a ordenação de chaves que tenham mais de um dígito (que é a situação real em
99% das vezes), estas devem ser divididas em partes de apenas um dígito. Assim o número
235 é dividido em 2, 3 e 5, e estes são analisados separadamente para serem ordenados.
Inicia-se ordenando as chaves de acordo com o dígito da posição 1 (menos
significativo), utilizando para isso um algoritmo baseado no princípio da limitação de dígitos.
Passe então para o ordenação pelo dígito da posição 2, depois pelo dígito da posição 3 e assim
por diante, até o número máximo de dígitos que as chaves podem ter (posição do dígito mais
significativo).
Essa ordem, do dígito menos significativo até o mais significativo, deve ser seguida
por causa do princípio do valor de um dígito pela sua posição, é o dígito mais significativo
que define se um número é maior ou menor que outro.

3 Algoritmo
Para ilustrar o método que foi apresentado e como ele pode ser implementado vamos
utilizar algoritmo em pseudo código, também chamado de português estruturado.

3.1 Código

Programa Principal:
Início
Para cada posição começando pela 1 até a máxima que as chaves podem ter
Ordenar o vetor pelo dígito dessa posição
Fim

Ordenar Vetor pelo Dígito da Posição X:

Início
Criar um vetor chamado Fila, da posição 0 até a 9, de filas
Para cada elemento do Vetor
F = Obter o dígito desse elemento na Posição X
Colocar esse elemento na Fila F

7
 A Posição Atual do Vetor é o seu início
Para Y = 0 até 9
Colocar cada elemento da Fila[Y] no Vetor a partir da Posição Atual
A Posição Atual do Vetor é o seu próprio valor somado ao tamanho da Fila[Y]
Fim

3.2 Aplicação

Vamos executar o algoritmo acima em um vetor exemplo para verificar como é dada
a ordenação:

Tabela 3: Vetor Exemplo

Posição Dado (Chave)

1 15
2 2
3 21
4 11
5 8
6 1
7 30
8 9
9 10
10 6

Passo 1:
Para cada posição começando pela 1 até a máxima que as chaves podem ter
Ordenar o vetor pelo dígito dessa posição
Neste vetor os dados (chaves) têm no máximo 2 dígitos: unidade e dezena. Então o
laço será executado duas vezes e a variável posição assumirá os valores 1, na primeira
execução e 2 na segunda. Dentro desse lado é chamada a subrotina que ordena o vetor de
acordo com o dígito da posição que passamos como parâmetro.

Passo 2:
Ordenar Vetor pelo Dígito da Posição X:
Início
Criar um vetor chamado Fila, da posição 0 até a 9, de filas
Já dentro da subrotina, o primeiro comando é criar um vetor de filas com tamanho
10, indo de 0 até 9.

Tabela 4: O vetor de 10 filas criado

Fila Elementos
0
1
2
3
4
5

8
6
7
8
9

Passo 3:
Para cada elemento do Vetor
F = Obter o dígito desse elemento na Posição X
Colocar esse elemento na Fila F
Este laço executa uma ordenação pelo dígito da posição que foi passada como
parâmetro, neste primeiro caso, como foi visto no passo 1 será a posição 1, que corresponde à
casa das unidades. Para cada dado do vetor será verificado o dígito da casa das unidades e este
dado será colocado na fila correspondente a este dígito. Por exemplo, se o dígito das unidades
de um número for 6 esse número será colocado na fila 6 (vetor Fila na posição 6, Fila[6]).
Abaixo como fica o vetor de filas com a aplicação desse laço sobre o nosso vetor exemplo.

Tabela 5: Ordenação do vetor pela casa das unidades

Fila Elementos
0 30, 10
1 21, 11, 1
2 2
3
4
5 15
6 6
7
8 8
9 9

Passo 4:
A Posição Atual do Vetor é o seu início
Para Y = 0 até 9
Colocar cada elemento da Fila[Y] no Vetor a partir da Posição Atual
A Posição Atual do Vetor é o seu próprio valor somado ao tamanho da Fila[Y]
Esta parte da subrotina nada mais faz do que “unir” as filas formando um vetor
parcialmente ordenado, neste caso, ordenado apenas pelas unidades. Os dados de cada fila,
começando pela 0 serão colocados no nosso vetor exemplo. Caso a ordenação desejada fosse
em ordem decrescente a primeira fila a ser lida deveria ser a 9. O nosso vetor exemplo ficará
como mostra a tabela abaixo.

Tabela 6: Vetor já ordenado pelas unidades

Posição Dado
1 30
2 10
3 21
4 11
5 1
6 2

9
7 15
8 6
9 8
10 9

Passo 5:
Com o fim da subrotina de ordenação por dígito, volta-se ao programa principal e é
encerrada a primeira volta do laço descrito no Passo 1. Porém ainda não se atingiu a posição
máxima que as chaves podem ter, que é 2. Então o laço recomeça, agora com a posição
acrescida de 1, totalizando 2. Segue-se o que foi descrito nos Passos 2 e 3, mas como
mudamos o parâmetro da rotina de ordenação por dígito para 2, o nosso vetor será ordenado
pelos dígitos da segunda posição: a casa das dezenas. Ao final da execução dos Passos 2 e 3 o
vetor de filas ficará como mostrado na tabela.

Tabela 7: Ordenação do vetor pela casa das dezenas

Fila Elementos
0 1, 2, 6, 8, 9
1 10, 11, 15
2 21
3 30
4
5
6
7
8
9

Passo 6:
É repetido o processo do passo 4, que forma o vetor novamente a partir das filas. O
fim da subrotina é atingido e novamente volta-se ao laço do programa principal. Como o vetor
já foi ordenado por todas as posições (unidade e dezena) o laço já atingiu o seu fim e o vetor
já está ordenado como abaixo.

Tabela 8: Vetor já ordenado pelas unidades e pelas dezenas

Posição Dado
1 1
2 2
3 6
4 8
5 9
6 10
7 11
8 15
9 21
10 30

4 Vantagens e Desvantagens

10
 Pelas características desse algoritmo ele apresenta algumas vantagens e desvantagens
que serão vistas a seguir.

4.1 Vantagens

• Utiliza pouco processamento (comparações) em relação aos outros algoritmos;

• Rápido para dados com poucos dígitos;

4.2 Desvantagens

• É necessário saber de antemão o número máximo de dígitos que os dados

podem ter, talvez com o uso de um laço, o que implica em uma varredura a mais do
vetor;
• Os passos intermediários, como a separação do dado em dígitos, podem usar
mais processamento que a própria ordenação.

11
 Conclusão

É interessante notar como certas coisas não perdem a utilidade. O algoritmo de

ordenação por distribuição de chaves ainda é bastante usado por sua simplicidade e
funcionalidade, e vem sendo usado desde os primórdios da computação. Seu método de
ordenação é simples, porém eficaz, utilizando apenas filas e o vetor que se está ordenando.
Não podemos dizer que este método é ultrapassado, velho ou etc. . Devido a sua
simplicidade, ele ainda vai ser muito usado, não tanto como o veloz Quick Sort, mas sua
utilidade esta longe de acabar.
Concluímos que este método teve grande importância bem no começo da era da
Informática, na época dos cartões perfurados. Mas devido a sua eficiência, ele sobreviveu e
continua sendo útil até hoje. Realmente é um algoritmo eficiente e realmente comprovamos
isso nesse trabalho. É, nem sempre o novo é melhor que o velho.

12
 Bibliografia

1 VILLAS, Marcos Vianna et al. Estruturas de Dados: Conceitos e Técnicas de

Implementação. Rio de Janeiro: Campus, 1993.

2 LOPES, Arthur Vargas. Estruturas de Dados para a Construção de Software: Volume 2.

Canoas: Ulbra, 1999.

3 TENENBAUM, Aaron M.; LANGSAN, Yedidyah; AUGENSTEIN, Moshe J. Estruturas de

Dados Usando C. São Paulo: Makron, 1995.

4 VELOSO, Paulo et al. Estruturas de Dados. Rio de Janeiro: Campus, 1983.

5 MÜLLER, Daniel Nehme. Ordenação de Dados. Canoas. Disponível por WWW em:
http://www.ulbra.tche.br/~danielnm/ed/C/polC.html (03/2002).

13