O documento descreve o algoritmo de ordenação por contagem (counting sort). Ele ordena vetores em tempo linear sem usar comparações, mas requer dois vetores adicionais de espaço na memória. O algoritmo conta o número de ocorrências de cada elemento e usa essas contagens para determinar as posições dos elementos ordenados no vetor de saída.

1. Ordenação por Contagem
 Algoritmo apresentado:
 Counting Sort

2. COUNTING SORT
 Aspectos Positivos:
 Ordena vetores em tempo linear para o tamanho
do vetor inicial;
 Não realiza comparações;
 É um algoritmo de ordenação estável;

3. COUNTING SORT
 Aspecto Negativo:
 Necessita de dois vetores adicionais para sua
execução, utilizando, assim, mais espaço na
memória.

4. COUNTING SORT
 Funcionamento:
 A ordenação por contagem pressupõe que cada
um dos n elementos do vetor de entrada é um
inteiro entre 0 e k (k representa o maior inteiro
presente no vetor).
 A ideia básica é determinar, para cada elemento de
entrada x, o numero de elementos menores ou
iguais a x. Com essa informação é possível
determinar exatamente onde o elemento x será
inserido.

5. ALGORITMO
COUNTING SORT
01 CountingSort(A, B, k)
02 for i0 to k
03 C[i] 0
04 for i1 to comprimento [A]
05 C[A[i]]++
06 for i1 to k
07 C[i] += C[i-1]
08 for i 0 to comprimento [A]
09 B[C[A[i]]-1] = A[i]
10 C[A[i]] -= 1

6. SIMULAÇÃO - COUNTING
SORT
O algoritmo recebe um vetor desordenado como entrada:
Em seguida, gera os vetores adicionais B e C:
 O vetor B é do mesmo tamanho do vetor A (8 elementos).
 O vetor C é do tamanho do maior elemento de A + 1 (5 + 1 = 6).
0 0 0 0 0 0C =
0 1 2 3 4 5
B =
0 1 2 3 4 5 6 7
2 5 3 0 2 3 0 3A =
0 1 2 3 4 5 6 7

7. SIMULAÇÃO - COUNTING
SORT
Se o valor de um elemento de entrada é i, incrementamos C[i]:
C[i] contém um número de elementos de entrada igual a i para
cada i = 0,1,2,...,k.
2 0 2 3 0 1C =
0 1 2 3 4 5
Agora fazemos C[i] = C[i] + C[i-1] para determinarmos quantos
elementos de entrada são menores que ou iguais a i, onde i inicia
com 1.
2 2 4 7 7 8C =
0 1 2 3 4 5

8. SIMULAÇÃO - COUNTING
SORT
Agora, partindo do menor para o maior índice, fazemos
B[C[A[i]] -1] = A[i] Assim, colocamos cada elemento A[i] em sua
Posição ordenada no vetor B:
Para i = 0
B[C[A[0]] -1]  B[C[2] -1]
B[4 -1]  B[3] = A[0]
B[3] = 2
Exemplo: 2 5 3 0 2 3 0 3A =
0 1 2 3 4 5 6 7
2 2 4 7 7 8C =
0 1 2 3 4 5
B =
0 1 2 3 4 5 6 7

9. SIMULAÇÃO - COUNTING
SORT
Em seguida decrementamos o valor de C[A[j]] toda vez que
Inserimos um valor no vetor B. isso faz com que o próximo
elemento de entrada com valor igual a A[j], se existir, vá para
a posição imediatamente anterior a A[j] no vetor B.
C[3] = C[3] – 1:
2 2 4 7 7 8C =
0 1 2 3 4 5
2 2 3 7 7 8C =
0 1 2 3 4 5

10. SIMULAÇÃO - COUNTING
SORT
Após as iterações de (comprimento de 0 até [k] ) temos o vetor de
saída B ordenado!!!
0 0 2 2 3 3 3 5B =
0 1 2 3 4 5 6 7