Anlise de Algoritmos

Counting Sort

Nome: Andrew Gama

Nome: Rony Conde

Counting Sort
Funcionamento:

A ordenao por contagem pressupe que cada um dos n

elementos do vetor de entrada um inteiro entre 1 e k (onde
k representa o maior inteiro presente no vetor).

A idia bsica determinar, para cada elemento de entrada x,

o numero de elementos menores ou iguais a x. Com essa
informao possvel determinar exatamente onde o
elemento x ser inserido.

Counting Sort
Aspectos Positivos:
Ordena vetores em tempo linear para o tamanho do vetor
inicial;
No realiza comparaes;
um algoritmo de ordenao estvel;
Aspecto Negativo:

Necessita de dois vetores adicionais para sua execuo,

utilizando, assim, mais espao na memria.

Counting Sort
Complexidade:

O algoritmo no faz comparaes entre elementos de A!

Sua complexidade deve ser medida em funo do nmero
das outras operaes, aritmticas, atribuies, etc.
Claramente, a complexidade de COUNTING-SORT :
O(n + k). Quando k O(n), ele tem complexidade O(n).

Counting Sort
Array A 0
0

2
1

0
2

1
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

Array C
0

Array B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

0
0

2
1

0
1

0
2

0
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Inicializar valores do Vetor C em 0.

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1
0

2
1

0
1

0
2

0
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1
0

2
1

0
1

0
2

1
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

0
1

0
2

1
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

1
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

2
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

2
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

2
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

3
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Contagem do numero de cada

elemento do intervalo do Vetor A

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

3
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

1
1

0
2

3
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

3
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

3
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

0
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

6
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

6
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

6
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Realizar Complementos de casa de cada

valor no Vetor C

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

6
2

1
3

6
3

2
4

4
5

4
6

2
7

for i 0 to k do
C[A[j]] C[A[j]]+1;
endfor

for i 0 to k do
C[i] C[i]+C[i-1];
endfor

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

1
3

6-1 6
2

2
4

4
5

4
6

2
7

for i
C[A[j]]
endfor

8
4

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

5
2

1
3

6
3

2
4

4
5

4
6

for i
C[A[j]]
endfor

8
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

5
2

1
3

6
3

2
4

4
5

4
6

for i
C[A[j]]
endfor

8-1
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

5
2

1
3

6
3

2
4

4
5

for i
C[A[j]]
endfor

7
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

4
6

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

5
2

1
3

6
3

2
4

4
5

for i
C[A[j]]
endfor

7-1
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

4
6

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

5
2

1
3

6
3

2
4

for i
C[A[j]]
endfor

2
1

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

1
3

5-1 6
2

2
4

for i
C[A[j]]
endfor

2
1

B
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

3
1

0
2

4
2

1
3

6
3

for i
C[A[j]]
endfor

6
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

0
2

3-1 4
1

1
3

6
3

for i
C[A[j]]
endfor

6
4

2
0

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
0

2
1

2
1

0
2

4
2

6
3

1
0

for i
C[A[j]]
endfor

6
4

2
3

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

2
1

2-1 2
0

0
2

4
2

6
3

1
0

for i
C[A[j]]
endfor

6
4

2
3

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1
0

2
1

2
1

0
0

4
2

6
3

1
2

for i
C[A[j]]
endfor

6
4

2
3

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1
0

2
1

2
1

0
0

4-1 6
2

1
2

for i
C[A[j]]
endfor

6
4

2
3

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1
0

2
1

0
0

3
2

1
2

6
3

2
3

for i
C[A[j]]
endfor

6
4

2
4

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

1-1 2
0

0
0

3
2

1
2

6
3

2
3

for i
C[A[j]]
endfor

6
4

2
4

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A
0

0
0

0
0

2
1

0
1

3
2

1
2

6
3

2
3

for i
C[A[j]]
endfor

6
4

2
4

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

Alocar Valores no Vetor Ordenado (Vetor

B)

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A
0

0
0

0
0

2
1

0
1

3
2

1
2

6
3

2
3

for i
C[A[j]]
endfor

6
4

2
4

CountingSort (A, B,
k)
for i 0 to k do
C[i] 0;
endfor

2
5

4
6

4
7

0 to k do
C[A[j]]+1;

for i 0 to k do
C[i] C[i]+C[i-1];
endfor
forj n downto1 do
B[C[A[j]]] A[j];
C[A[j]] C[A[j]]-1;
endfor

Counting Sort
A

0
0

0
0

2
1

0
0

3
2

1
2

6
3

2
3

6
4

2
4

2
5

4
6

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

3
2

1
0

6
3

2
3

6
4

2
4

2
5

4
6

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

1
2

3
2

6
3

2
0

6
4

2
4

2
5

4
6

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

1
2

3
2

2
3

6
3

6
4

2
0

2
5

4
6

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

1
2

3
2

2
3

6
3

2
4

2
1

B
0

4
6

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

1
2

3
2

2
3

6
3

2
4

2
5

6
4

4
0

4
7

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
0

0
1

2
1

1
2

3
2

2
3

6
3

2
4

2
5

4
6

6
4

4
0

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
1

1
2

2
3

2
4

Passar Contedo do Vetor B, para o

Original (Vetor A)

Counting Sort
A

0
0

0
1

1
2

2
3

2
4

Passar Contedo do Vetor B, para o

Original (Vetor A)

Implementao Counting
Sort