Introdução

Material e Métodos

O objetivo deste trabalho foi a execução de um teste de dois tipos de

algoritmos de ordenação, o Bubble Sort e o Shell Sort.
Cada algoritmo foi transformado para gerar uma sequência ordenada
em ordem crescente, e em ordem decrescente, totalizando então, 4 algoritmos.
Cada um deles recebeu uma certa quantidade de entradas, e foi
compilado para gerar as sequências desejadas.
Foram inseridas entradas de 25.000 em 25.000 números, iniciando-se
pelo número 10.000, e finalizando, portanto, com a entrada de 250.000
números.
Tais números foram gerados aleatória e automaticamente pelo excel,
por meio da função “ALEATÓRIOENTRE”, que retorna um número aleatório
inteiro entre os números especificados, que contém os seguintes argumentos:
o menor número inteiro que poderá ser retornado aleatoriamente e o maior
inteiro que poderá ser retornado aleatoriamente.
A fórmula foi estendida de acordo com a quantidade no título de cada
coluna, gerando, por exemplo, 100.000 números aleatórios na coluna E,
125.000 números aleatórios na coluna F, e assim por diante.
 Os números desejados foram copiados e inseridos no array dos
códigos (linha 7 para os códigos de Bubble Sort e linha 5 para os códigos de
Shell Sort), de acordo com a quantidade de entradas que desejou-se analisar.
O experimento foi conduzido utilizando-se as seguintes tabelas de
dados. A primeira é referente ao experimento conduzido numa máquina de
processador AMD Ryzen 5 2400G 3.6GHz com 4GB de memória RAM. A
segunda tabela se trata de uma máquina com processador Intel Core i7 7700k
4.2GHz com uma memória RAM de 16GB.
Nas quais as primeiras colunas representam quantidade de números
dados como entrada nos arrays dos códigos de Bubble Sort, as segundas
colunas representando o tempo final de execução obtido do código de
ordenação em ordem crescente para cada entrada correspondente, e as
terceiras, os mesmos tempos para a ordem decrescente.
Já as quartas colunas indicam as entradas para o código de Shell Sort,
com as quintas colunas incluindo o tempo de ordenação em ordem crescente
para as entradas das quarats colunas, e finalmente, as sextas colunas, o
resultado do tempo de execução do código de ordenação em ordem
decrescente.

AMD Ryzen 5 2400G 3.6GHz 4GB RAM

Buble Sort   Shell Sort
Entradas (n) Crescente Decrescente   Entradas (n) Crescente Decrescente
10.000 1,2 1,3   10.000 0,7417 0,797
25.000 4,14 4.15   25.000 1,8 1,74
50.000 13,4 13,5   50.000 3,27 3,23
75.000 26,79 26,5   75.000 4,81 4,678
100.000 46,8 50   100.000 6,33 6,366
125.000 70,25 70,89   125.000 7,52 8,11
150.000 98,21 98,56   150.000 11,42 9,36
175.000 131,5 165,7   175.000 11,51 10,97
200.000 178,2 172,2   200.000 11,64 12,05
225.000 239 224,7   225.000 12,78 12,94
 Intel Core i7 7700k 4.2GHz 16GB RAM
Buble Sort   Shell Sort
Entradas (n) Crescente Decrescente   Entradas (n) Crescente Decrescente
10.000 1,11 1,129   10.000 1,242 1,044
25.000 3,61 3,5   25.000 1,681 1,904
50.000 9,28 9,36   50.000 2,963 2,906
75.000 20,36 20,71   75.000 3,894 3,961
100.000 32,19 32,53   100.000 5,025 5,002
125.000 51,57 51,08   125.000 6,076 6,055
150.000 72,36 72,28   150.000 7,21 7,221
175.000 95,96 96,45   175.000 8,322 8,339
200.000 120 121,4   200.000 9,526 9,348
250.000 154,5 153,6   250.000 10,49 10,51
 Resultados

Considerando os resultados obtidos, pode-se construir quatro gráficos

de dispersão para que se observasse o comportamento de cada código em
sistemas operacionais distintos. E para calcular a fórmula da regressão linear
para que fosse possível prever resultados duas, dez e a até cem vezes maiores
em comparação com as entradas aqui inseridas. Foi também obtido o resultado
do coeficiente de determinação, ou R2, uma das formas de avaliar a qualidade
do ajuste do modelo, que indica quanto o modelo foi capaz de explicar os
dados coletados.
Tomando os dados do Bubble Sort em ordem crescente para a
máquina de processador Ryzen 5, foi obtido o seguinte gráfico de dispersão:

Bubble Sort - Ryzen 5 - Ordem Crescente

300

250

200
f(x) = 0 x − 37.46
Tempo (s)

150 R² = 0.92

100

50

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Indicando-se uma boa correlação (R2 = 0,9218). A partir da fórmula de

regressão linear para estes dados y = 0,001x – 37,457 (em amarelo), foi-se
capaz de prever os resultados de tempo de ordenação para as seguintes
quantidades de dados (N):
 Previsões
hh:mm:s
N Tempo (s)
  s
500.000 462,543   00:07:43
1.000.000 962,543   00:16:03
10.000.000 9.962,543   02:46:03
99.962,54
100.000.000
3   03:46:03

A segunda coluna mostra o tempo em segundos, e a terceira, o tempo

convertido em horas, minutos e segundos.
Para a mesma máquina e mesmo tipo código, neste caso em ordem
decrescente, os resultados de tempo foram ligeiramente maiores, como indica
o gráfico e a tabela:

Bubble Sort - Ryzen 5 - Ordem Decrescente

250

200
f(x) = 0 x − 36.82
R² = 0.94
150
Tempo (s)

100

50

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Previsões
hh:mm:s
N Tempo (s)
  s
500.000 463,176   00:07:43
1.000.000 963,176   00:16:03
10.000.000 9.963,176   02:46:03
99.963,17
100.000.000
6   03:46:03
 Para o código de Shell Sort para ordenação em ordem crescente, ainda
executado na máquina de processador Ryzen 5, os resultados foram mais
rápidos e as correlações maiores em comparação com os dois anteriores:

Shell Sort - Ryzen 5 - Ordem Crescente

14
f(x) = 0 x + 0.45
12 R² = 0.96
10
Tempo (s)

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Previsões
N Tempo (s) hh:mm:ss
500.000 30,454 00:00:30
1.000.000 60,454 00:01:00
10.000.000 600,454 00:10:00
100.000.000 6.000,454 01:40:00

Considerando ainda o mesmo processador e mesmo código, agora

para ordem decrescente, obtiveram-se os seguintes resultados:

Shell Sort - Ryzen 5 - Ordem Decrescente

14
f(x) = 0 x + 0.39
12
R² = 1
10
Tempo (s)

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

 Previsões
N Tempo (s)   hh:mm:ss
500.000 30,391   00:00:30
1.000.000 60,391   00:01:00
10.000.000 600,391   00:10:00
100.000.000 6.000,391   01:40:00

Assim como o Bubble Sort, o código para ordenação decrescente por

Shell Sort também resultou em tempos de execução ligeiramente maiores,
porém esta diferença se tornou insignificante ao se tratar de grandes
quantidades de entradas.
Tratando-se da máquina com processador Intel i7, os resultados para o
código de ordenação crescente Bubble Sort foram os seguintes:

Bubble Sort - Intel i7 - Ordem Crescente

180
160
140
120 f(x) = 0 x − 23.17
R² = 0.95
Tempo (s)

100
80
60
40
20
0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Previsões
N Tempo (s)   hh:mm:ss
500.000 326,831   00:05:27
1.000.000 676,831   00:11:17
10.000.000 6.976,831   01:56:17
100.000.000 69.976,831   19:26:17
 Estes resultados já apresentam uma melhor correlação e menor tempo
de execução em comparação com o processador anterior. Em relação aos
resultados desta máquina para este código, mas em ordem decrescente, foram
obtidos os resultados:

Bubble Sort - Intel i7 - Ordem Decrescente

180
160
140
120 f(x) = 0 x − 23.12
R² = 0.95
Tempo (s)

100
80
60
40
20
0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Previsões
N Tempo (s)   hh:mm:ss
500.000 326,879   00:05:27
1.000.000 676,879   00:11:17
10.000.000 6.976,879   01:56:17
100.000.000 69.976,879   19:26:17

Já para o código Shell Sort, para a máquina com processador Intel i7

em ordenação crescente, obteve-se:
 Shell Sort - Intel i7 - Ordem Crescente
12

10 f(x) = 0 x + 0.69
R² = 1
8
Tempo (s)

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

Previsões
N Tempo (s)   hh:mm:ss
500.000 20,691   00:00:21
1.000.000 40,691   00:00:41
10.000.000 400,691   00:06:41
100.000.000 4.000,691   01:06:41

Percebe-se uma correlação quase perfeita, não diferente da obtida pelo

código na mesma máquina em ordenação decrescente:

Shell Sort - Intel i7 - Ordem Decrescente

12

10 f(x) = 0 x + 0.7
R² = 1
8
Tempo (s)

0
0 50,000 100,000 150,000 200,000 250,000
Entradas (n)

Tempo Linear (Tempo)

 Previsões
N Tempo (s)   hh:mm:ss
500.000 20,700   00:00:21
1.000.000 40,700   00:00:41
10.000.000 400,700   00:06:41
100.000.000 4.000,700   01:06:41
 Conclusões

Ao considerar-se apenas uma simples comparação de algoritmos,

Bubble Short e Shell Sort, pode-se concuilr que o Shell Sort é bem mais
eficiente que o primeiro, já que numa situação mais extrema com 100.000.000
números de entrada para ordenação, o algoritmo Shell Sort é capaz de concluir
o processo em aproximadamente 34 minutos a menos que o Bubble Sort, tanto
numa ordenação crescente, como numa decrescente.
Além disso, seu coeficiente de determinação é mais próximo de 1 em
todas as ocasiões, indicando