Apresentação sobre o algoritmo de ordenação Counting Sort, apresentada no 2º semestre de 2014, como um dos requisitos da disciplina de Projeto e Análise de Algoritmos, no Mestrado em Ciência da Computação, pela Universidade Federal de Lavras (UFLA). Disciplina ministrada pelo professor Dr. Sanderson L. Gonzaga de Oliveira.

1. Counting Sort
Fernando Simeone
Mestrado em Ciência da Computação
Universidade Federal de Lavras
!
Projeto e Análise de Algoritmos (2014/2)

2. Tópicos
• O algoritmo
• Análise de complexidade
• Conclusão
• Referências

3. O algoritmo

4. Idéia algoritmo
Para cada elemento do array
!
Contar quantos elementos há menores do que ele
!
Inserir o elemento em sua posição correta

5. Entradas
Counting-Sort( input, output, k )

6. Entradas
Counting-Sort( input, output, k )
2 5 3 0 2 3 0 3
input

7. Entradas
Counting-Sort( input, output, k )
2 5 3 0 2 3 0 3
input
inteiros maiores
ou iguais a 0

8. Entradas
Counting-Sort( input, output, k )
2 5 3 0 2 3 0 3
input
output
inteiros maiores
ou iguais a 0

9. Entradas
Counting-Sort( input, output, k )
2 5 3 0 2 3 0 3
input
output
k = 5
inteiros maiores
ou iguais a 0

10. Entradas
Counting-Sort( input, output, k )
2 5 3 0 2 3 0 3
input
output
k = 5
inteiros maiores
ou iguais a 0

11. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
output

12. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
output
1 - Inicialização
0 1 2 3 4 5 6 7

13. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 1 2 3 4 5 6 7

14. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 1 2 3 4 5 6 7

15. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0
0 1 2 3 4 5 6 7

16. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 0
0 1 2 3 4 5 6 7

17. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 0 0
0 1 2 3 4 5 6 7

18. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 0 0 0
0 1 2 3 4 5 6 7

19. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 0 0 0 0
0 1 2 3 4 5 6 7

20. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
k = 5
2 5 3 0 2 3 0 3
count
0 1 2 3 4 5
output
1 - Inicialização
0 0 0 0 0 0
0 1 2 3 4 5 6 7

21. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
0 0

22. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
0 0
j = 0

23. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
0 0
j = 0
count[2] = count[2] + 1

24. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
0 0
+ 1
j = 0
1
count[2] = count[2] + 1

25. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 0
j = 1

26. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 0
j = 1
count[5] = count[5] + 1

27. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 0
+ 1
j = 1
1
count[5] = count[5] + 1

28. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 1
j = 2

29. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 1
j = 2
count[3] = count[3] + 1

30. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 0 0 0
5
output
2 - Contagem A
1 1
+ 1
j = 2
1
count[3] = count[3] + 1

31. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 1 0 0
5
output
2 - Contagem A
1 1
j = 3

32. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 1 0 0
5
output
2 - Contagem A
1 1
j = 3
count[0] = count[0] + 1

33. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 0 0 1 0 0
5
output
2 - Contagem A
1 1
+ 1
j = 3
1
count[0] = count[0] + 1

34. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
1 1
j = 4

35. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
1 1
j = 4
count[2] = count[2] + 1

36. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
1 1
+ 1
j = 4
2
count[2] = count[2] + 1

37. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
2 1
j = 5

38. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
2 1
j = 5
count[3] = count[3] + 1

39. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 1 0 0
5
output
2 - Contagem A
2 1
+ 1
j = 5
2
count[3] = count[3] + 1

40. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 2 0 0
5
output
2 - Contagem A
2 1
j = 6

41. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 2 0 0
5
output
2 - Contagem A
2 1
j = 6
count[0] = count[0] + 1

42. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 0 0 2 0 0
5
output
2 - Contagem A
2 1
+ 1
j = 6
2
count[0] = count[0] + 1

43. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
2 5 3 0 2 3 0 3
O algoritmo
input
count
0 1 2 3 4
2 0 0 2 0 0
5
output
2 - Contagem A
2 1
j = 7

44. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
2 5 3 0 2 3 0 3
O algoritmo
input
count
0 1 2 3 4
2 0 0 2 0 0
5
output
2 - Contagem A
2 1
j = 7
count[3] = count[3] + 1

45. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
2 5 3 0 2 3 0 3
O algoritmo
input
count
0 1 2 3 4
2 0 0 2 0 0
5
output
2 - Contagem A
2 1
+ 1
j = 7
3
count[3] = count[3] + 1

46. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 1
0 1 2 3 4 5 6 7

47. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 1
+
0 1 2 3 4 5 6 7

48. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12
+
0 1 2 3 4 5 6 7

49. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12
+
0 1 2 3 4 5 6 7

50. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4
+
0 1 2 3 4 5 6 7

51. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4
+
0 1 2 3 4 5 6 7

52. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4 7
+
0 1 2 3 4 5 6 7

53. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4 7
+
0 1 2 3 4 5 6 7

54. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4 7 7
+
0 1 2 3 4 5 6 7

55. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4 7 7
+
0 1 2 3 4 5 6 7

56. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 0 0 3 0 0
5
output
2 - Contagem B
2 12 4 7 7 8
0 1 2 3 4 5 6 7

57. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 7 7 0
5
output
3 - Ordenação
4 8
0 1 2 3 4 5 6 7

58. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 7 7 0
5
output
3 - Ordenação
4 8
j = 7
0 1 2 3 4 5 6 7

59. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 7 7 0
5
output
3 - Ordenação
4 8
- 1
j = 7
0 1 2 3 4 5 6 7

60. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 7 7 0
5
output
3 - Ordenação
4 8
- 1
j = 7
0 1 2 3 4 5 6 7
3

61. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 7 7 0
5
output
3 - Ordenação
4 8
- 1
j = 7
0 1 2 3 4 5 6 7
6
3

62. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 6 7 0
5
output
3
3 - Ordenação
4 8
j = 6
0 1 2 3 4 5 6 7

63. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 6 7 0
5
output
3
3 - Ordenação
4 8
- 1
j = 6
0 1 2 3 4 5 6 7

64. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 6 7 0
5
output
3
3 - Ordenação
4 8
- 1
j = 6
0 1 2 3 4 5 6 7
0

65. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
2 2 0 6 7 0
5
output
3
3 - Ordenação
4 8
- 1
j = 6
0 1 2 3 4 5 6 7
1
0

66. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 6 7 0
5
output
0 3
3 - Ordenação
4 8
j = 5
0 1 2 3 4 5 6 7

67. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 6 7 0
5
output
0 3
3 - Ordenação
4 8
- 1
j = 5
0 1 2 3 4 5 6 7

68. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 6 7 0
5
output
0 3
3 - Ordenação
4 8
- 1
j = 5
0 1 2 3 4 5 6 7
3

69. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 6 7 0
5
output
0 3
3 - Ordenação
4 8
- 1
j = 5
0 1 2 3 4 5 6 7
5
3

70. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 3 3
3 - Ordenação
4 8
j = 4
0 1 2 3 4 5 6 7

71. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 3 3
3 - Ordenação
4 8
- 1
j = 4
0 1 2 3 4 5 6 7

72. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 3 3
3 - Ordenação
4 8
- 1
j = 4
0 1 2 3 4 5 6 7
2

73. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 3 3
3 - Ordenação
4 8
- 1
j = 4
0 1 2 3 4 5 6 7
3
2

74. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 2 3 3
3 - Ordenação
3 8
j = 3
0 1 2 3 4 5 6 7

75. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 2 3 3
3 - Ordenação
3 8
- 1
j = 3
0 1 2 3 4 5 6 7

76. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 2 3 3
3 - Ordenação
3 8
- 1
j = 3
0 1 2 3 4 5 6 7
0

77. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
1 2 0 5 7 0
5
output
0 2 3 3
3 - Ordenação
3 8
- 1
j = 3
0 1 2 3 4 5 6 7
0
0

78. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 5 7 0
5
output
0 0 2 3 3
3 - Ordenação
3 8
j = 2
0 1 2 3 4 5 6 7

79. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 5 7 0
5
output
0 0 2 3 3
3 - Ordenação
3 8
- 1
j = 2
0 1 2 3 4 5 6 7

80. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 5 7 0
5
output
0 0 2 3 3
3 - Ordenação
3 8
- 1
j = 2
0 1 2 3 4 5 6 7
3

81. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 5 7 0
5
output
0 0 2 3 3
3 - Ordenação
3 8
- 1
j = 2
0 1 2 3 4 5 6 7
4
3

82. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3
3 - Ordenação
3 8
j = 1
0 1 2 3 4 5 6 7

83. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3
3 - Ordenação
3 8
- 1
j = 1
0 1 2 3 4 5 6 7

84. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3
3 - Ordenação
3 8
- 1
j = 1
0 1 2 3 4 5 6 7
5

85. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3
3 - Ordenação
3 8
- 1
j = 1
0 1 2 3 4 5 6 7
7
5

86. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3 5
3 - Ordenação
3 7
j = 0
0 1 2 3 4 5 6 7

87. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3 5
3 - Ordenação
3 7
- 1
j = 0
0 1 2 3 4 5 6 7

88. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3 5
3 - Ordenação
3 7
- 1
j = 0
0 1 2 3 4 5 6 7
2

89. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 3 3 3 5
3 - Ordenação
3 7
- 1
j = 0
0 1 2 3 4 5 6 7
2
2

90. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
0 1 2 3 4 5 6 7
O algoritmo
input
2 5 3 0 2 3 0 3
count
0 1 2 3 4
0 2 0 4 7 0
5
output
0 0 2 2 3 3 3 5
3 - Ordenação
2 7
0 1 2 3 4 5 6 7

91. Análise de
complexidade

92. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5

93. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5

94. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5

95. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5

96. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1

97. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n

98. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n
k + 1

99. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n
k + 1
k

100. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n
k + 1
k
n + 1

101. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n
k + 1
k
n + 1
n

102. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input1 - Pior caso
1
k + 2
k + 1
input
count
Output
0 1 2 3 4 5 6 7
5 3 3 3 2 2 0 0
0 1 2 3 4 5 6 7
0 1 2 3 4 5
n + 1
n
k + 1
k
n + 1
n
n

103. Análise de complexidade
1 - Pior caso

104. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
1 - Pior caso

105. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
1 - Pior caso

106. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = an + b
1 - Pior caso

107. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = an + b
a = c4 + c5 +c8 + c9 +c10
1 - Pior caso

108. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = an + b
a = c4 + c5 +c8 + c9 +c10
b = k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
1 - Pior caso

109. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = an + b
a = c4 + c5 +c8 + c9 +c10
b = k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = O(n) + O(k)
1 - Pior caso

110. Análise de complexidade
c1 + c2(k+2) + c3(k+1) + c4(n+1) + c5(n) + c6(k+1) + c7(k) + c8(n + 1)
+ c9(n)+ c10(n)
n (c4 + c5 +c8 + c9 +c10) + k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = an + b
a = c4 + c5 +c8 + c9 +c10
b = k (c2 + c3 + c6 +c7) + 2c2 + c3 + c4 +c6 + c8
T(n) = O(n) + O(k)
1 - Pior caso
= O(n + k)

111. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input2 - Melhor caso
input
0 0 2 2 3 3 3 5
0 1 2 3 4 5 6 7

112. Counting-sort (input, output, k)
!
1
count = new int [ k ]
!
2
for i = 0 to k
3
count[ i ] = 0
!
4
for j = 0 to input.length - 1
5
count[ input[ j ] ] = count[ input[ j ] ] + 1
!
6
for i = 1 to k
7
count[ i ] = count[ i ] + count[ i - 1 ]
!
8
for j = A.length - 1 downto 0
9
output[ count[ input[ j ] ] -1 ] = input[ j ]
10
count[ input[ j ] ] = count[ input[ j ] ] - 1
Análise de complexidade
input2 - Melhor caso
input
0 0 2 2 3 3 3 5
0 1 2 3 4 5 6 7
O número de operações!
não depende da!
ordem inicial do array

113. Análise de complexidade

114. Análise de complexidade
T(n) = 𝛩(n + k)

115. Análise de complexidade
T(n) = 𝛩(n + k)
Isso faz com que o counting sort seja uma boa opção quando
k ≤ n"
pois assim seu custo será 𝛩(n).

116. Conclusão

117. Conclusão

118. Conclusão
• Counting Sort é um algoritmo de complexidade
linear;

119. Conclusão
• Counting Sort é um algoritmo de complexidade
linear;
• Não respeita o limite inferior 𝝮 (n lg n) aplicado a
algoritmos baseados em comparações;

120. Conclusão
• Counting Sort é um algoritmo de complexidade
linear;
• Não respeita o limite inferior 𝝮 (n lg n) aplicado a
algoritmos baseados em comparações;
• Possui complexidade O(n) quando K ≤ n;

121. Conclusão
• Counting Sort é um algoritmo de complexidade
linear;
• Não respeita o limite inferior 𝝮 (n lg n) aplicado a
algoritmos baseados em comparações;
• Possui complexidade O(n) quando K ≤ n;
• É um algoritmo estável, valores iguais
permanecem na mesma ordem entre si.

122. Referências

123. Referências
CORMEN, T. H.; LEISERSON, C. E.; RIVEST, R. L.; STEIN, C.
Introduction to Algorithms, Third Edition. 3rd. ed. [S.l.]: The
MIT Press, 2009. ISBN 0262033844, 9780262033848.
!
Gonzaga de Oliveira, S.L. . Algoritmos e seus fundamentos. 1.
ed. Lavras: Editora UFLA, 2011. v. 300. 440p .