Análise de desempenho de algoritmos de ordenação

ANÁLISE DE COMPORTAMENTO E DESEMPENHO DE
ALGORITMOS DE ORDENAÇÃO
TRABALHO PARA A DISCIPLINA DE PROJETO E ANÁLISE DE ALGORITMO
CURSO DE ENGENHARIA DE COMPUTAÇÃO
BRUNO MOURÃO SIQUEIRA
UNIVERSIDADE BRAZ CUBAS
MOGI DAS CRUZES

ANÁLISE DE COMPORTAMENTO E DESEMPENHO DE
ALGORITMOS DE ORDENAÇÃO
TRABALHO PARA A DISCIPLINA DE PROJETO E ANÁLISE DE ALGORITMO
BRUNO MOURÃO SIQUEIRA – RGM 170622
ORIENTADOR PROF. Dr. ANGELO PASSARO
UNIVERSIDADE BRAZ CUBAS
CURSO ENGENHARIA DE COMPUTAÇÃO
MOGI DAS CRUZES
2005

ANÁLISE DE COMPORTAMENTO E DESEMPENHO DE ALGORITMOS DE ORDENAÇÃO
i
SUMÁRIO
RESUMO ...................................................................................................................................1
MATERIAIS E MÉTODOS.......................................................................................................2
IDENTIFIAÇÃO DAS OPERAÇÕES RELEVANTES........................................................2
ALGORITMO BUBLESORT................................................................................................4
ALGORITMO MERGESORT...............................................................................................5
ALGORITMO QUICKSORT ................................................................................................6
ALGORITMO SELEÇÃO .....................................................................................................7
ALGORITMO INSERÇÃO...................................................................................................8
RESULTADOS ..........................................................................................................................9
COMPARAÇÃO DE QUANTIDADES DE OPERAÇÕES .................................................9
COMPARAÇÃO DE TEMPO DE ORDENAÇÃO.............................................................10
GRÁFICOS ..........................................................................................................................10
CONCLUSÕES........................................................................................................................20
ÍNDICE DE FIGURAS ............................................................................................................21
REFERENCIAS BIBLIOGRÁFICAS .....................................................................................22

Página 1 de 22
RESUMO
Com os avanços da ciência e da tecnologia nas últimas décadas, a demanda por
informações vêm crescendo em escala geométrica. A acessibilidade a meios
computacionais e a sistemas em redes por uma fatia considerável da população, maior
acuracidade em experimentos e a viabilidade de criação de novas ferramentas e técnicas
são reflexos, facilmente identificáveis, desta revolução tecnológica.
Em todos os casos citados as necessidades de acesso e geração de informações
são fatores comumente críticos, tanto em questão de velocidade – na gravação, na busca
–, ou seja de capacidade – armazenamento de quantidades de dados cada vez maiores.
Esta problemática conseqüente abre margem ao desenvolvimento de abordagens que se
incubem em minimizá-la.
No âmbito computacional, o emprego de análises no projeto de algoritmos é o
foco que permite selecionar dentre várias técnicas de processamento de informações,
qual melhor se adequa a um determinado problema. O estudo do comportamento dos
algoritmos em função de suas variáveis – como tempo, velocidade, quantidade de
dados, organização dos dados de entrada/saída, etc – é o artifício empregado para a
determinação de desempenho. E é nesta linha de estudo que se concentra este trabalho,
em especial na análise de desempenho de um procedimento corriqueiramente
encontrado nos casos citados acima e em outros diversos, a ordenação de informações.
Serão avaliados cinco métodos de ordenação – BUBLESORT, INSERÇÃO,
SELEÇÃO, MERGESORT, QUICKSORT – para números inteiros de 32 Bits e foco
nas variáveis de tempo, quantidade de dados e organização dos dados de entrada, de
cada um dos métodos. Objetivando-se um confrontamento dos resultados obtidos em
experimentos práticos com as premissas abordadas pelos estudos teóricos extraídos de
PASSARO, A. [1].
Com esse objetivo segue uma sucinta apresentação dos algoritmos envolvidos
neste trabalho e de suas características; descrição e observações dos procedimentos de
teste efetuados e dos resultados obtidos; análise gráfica dos desempenhos dos
algoritmos; conclusões sobre o estudo; e uma listagem das referências consultadas.

Página 2 de 22
MATERIAIS E MÉTODOS
Os métodos de ordenação têm por objetivo, a partir de um conjunto de dados
qualquer, ordená-los seguindo alguma regra, no caso ordem crescente. Dentre os
métodos de busca, figuram os métodos de ordenação por troca, dos quais serão
estudados os métodos BUBLESORT, MERGESORT e QUICKSORT; os métodos de
ordenação por seleção e os métodos de ordenação por inserção. As codificações são
adaptações dos programas desenvolvidos por UFB [2].
IDENTIFIAÇÃO DAS OPERAÇÕES RELEVANTES
A determinação de operações relevante num algoritmo tem como finalidade
obter parâmetros que traduzam o comportamento do mesmo, independente às possíveis
variações impostas pelo sistema em que o algoritmo está implementado e à quantidade e
ordenação dos dados de entrada. Com base nisto, ao observar o problema ordenar certa
quantidade de dados dispostos de uma maneira qualquer, independente do método
empregado, se destacam duas operações principais, a troca de valores de elementos,
indicada como atribuição, e comparação de valores de elementos, indicada como
comparação. A necessidade de execução da operação atribuição é sensível à disposição
dos valores dos elementos de entrada, com maior ou menor peso de um algoritmo para
outro, existindo casos críticos como o encontrado na figura 7, onde não é executada
nenhuma operação de atribuição.
As figuras de 6 a 20 contêm os gráficos de quantidades de operações abstratas
em função das quantidades de dados a ordenar para três casos. No primeiro caso os
dados estão dispostos aleatoriamente; no segundo os dados estão dispostos em ordem
crescente, já estão ordenados; e no terceiro os dados estão dispostos em ordem
decrescentes, o que configura o pior caso, porque todos os elementos estão nos lugares
errados. Analisando os gráficos conclui-se que o comportamento da operação de
comparação tem sempre uma ordem maior ou igual ao comportamento da operação de
atribuição e também se verifica que a soma do comportamento dessas duas operações
também não muda a ordem da curva, simplesmente a desloca para cima em comparação
ao comportamento individual da operação de atribuição, logo fica estabelecida como

SUMÁRIO
RESUMO ...................................................................................................................................1
MATERIAIS E MÉTODOS.......................................................................................................2
IDENTIFICAÇÃO DAS OPERAÇÕES RELEVANTES .....................................................2
ALGORITMO BUBLESORT................................................................................................4
ALGORITMO MERGESORT...............................................................................................5
ALGORITMO QUICKSORT ................................................................................................6
ALGORITMO SELEÇÃO .....................................................................................................7
ALGORITMO INSERÇÃO ...................................................................................................8
RESULTADOS ..........................................................................................................................9
COMPARAÇÃO DE QUANTIDADES DE OPERAÇÕES .................................................9
COMPARAÇÃO DE TEMPO DE ORDENAÇÃO.............................................................10
GRÁFICOS ..........................................................................................................................10
CONCLUSÕES........................................................................................................................21
ÍNDICE DE FIGURAS ............................................................................................................22
REFERÊNCIAS BIBLIOGRÁFICAS .....................................................................................23
i

RESUMO
Com os avanços da ciência e da tecnologia nas últimas décadas, a demanda por
informações vêm crescendo em escala geométrica. A acessibilidade a meios
computacionais e a sistemas em redes por uma fatia considerável da população, maior
acuracidade em experimentos e a viabilidade de criação de novas ferramentas e técnicas
são reflexos, facilmente identificáveis, desta revolução tecnológica.
Em todos os casos citados as necessidades de acesso e geração de informações
são fatores comumente críticos, tanto em questão de velocidade – na gravação, na busca
–, ou seja de capacidade – armazenamento de quantidades de dados cada vez maiores.
Esta problemática conseqüente abre margem ao desenvolvimento de abordagens que se
incubem em minimizá-la.
No âmbito computacional, o emprego de análises no projeto de algoritmos é o
foco que permite selecionar dentre várias técnicas de processamento de informações,
qual melhor se adequa a um determinado problema. O estudo do comportamento dos
algoritmos em função de suas variáveis – como tempo, velocidade, quantidade de
dados, organização dos dados de entrada/saída, etc – é o artifício empregado para a
determinação de desempenho. E é nesta linha de estudo que se concentra este trabalho,
em especial na análise de desempenho de um procedimento corriqueiramente
encontrado nos casos citados acima e em outros diversos, a ordenação de informações.
Serão avaliados cinco métodos de ordenação – BUBLESORT, INSERÇÃO,
SELEÇÃO, MERGESORT, QUICKSORT – para números inteiros de 32 Bits e foco
nas variáveis de tempo, quantidade de dados e organização dos dados de entrada, de
cada um dos métodos. Objetivando-se um confrontamento dos resultados obtidos em
experimentos práticos com as premissas abordadas pelos estudos teóricos extraídos de
PASSARO, A. [1].
Com esse objetivo segue uma sucinta apresentação dos algoritmos envolvidos
neste trabalho e de suas características; descrição e observações dos procedimentos de
teste efetuados e dos resultados obtidos; análise gráfica dos desempenhos dos
algoritmos; conclusões sobre o estudo; e uma listagem das referências consultadas.
Página 1 de 23

MATERIAIS E MÉTODOS
Os métodos de ordenação têm por objetivo, a partir de um conjunto de dados
qualquer, ordená-los seguindo alguma regra e neste trabalho a regra estipulada foi a
organização dos dados de saída em ordem crescente.
Dentre os métodos de busca, figuram os métodos de ordenação por troca, dos
quais serão estudados os métodos BUBLESORT, MERGESORT e QUICKSORT; os
métodos de ordenação por seleção e os métodos de ordenação por inserção. As
codificações são adaptações dos programas desenvolvidos por UFB [2].
IDENTIFICAÇÃO DAS OPERAÇÕES RELEVANTES
A determinação de operações relevante num algoritmo tem como finalidade
obter parâmetros que traduzam o comportamento do mesmo, independente às possíveis
variações impostas pelo sistema em que o algoritmo está implementado e à quantidade e
ordenação dos dados de entrada. Com base nisto, ao observar o problema ordenar certa
quantidade de dados dispostos de uma maneira qualquer, independente do método
empregado, se destacam duas operações principais, a atribuição (troca de valores de
elementos), e a comparação (comparação de valores de elementos). A necessidade de
execução da operação atribuição é sensível à disposição dos valores dos elementos de
entrada, com maior ou menor peso de um algoritmo para outro, existindo casos críticos
como o encontrado na figura 7, onde não é executada nenhuma operação de atribuição.
As figuras de 6 a 20 contêm os gráficos de quantidades de operações abstratas
em função das quantidades de dados a ordenar para três casos. No primeiro caso os
dados estão dispostos aleatoriamente; no segundo os dados estão dispostos em ordem
crescente, já estão ordenados; e no terceiro os dados estão dispostos em ordem
decrescentes, o que configura o pior caso, porque todos os elementos estão nos lugares
errados. Analisando os gráficos conclui-se que o comportamento da operação de
comparação tem sempre uma ordem maior ou igual ao comportamento da operação de
atribuição e também se verifica que a soma do comportamento dessas duas operações
também não muda a ordem da curva, simplesmente a desloca para cima em comparação
ao comportamento individual da operação de atribuição, logo fica estabelecida como
Página 2 de 23

única operação relevante para a análise dos algoritmos desse trabalho a operação
comparação.
Página 3 de 23

ALGORITMO BUBLESORT
void bublesort(int *B, long int contador)
{
long int a, b;
int t;
for (a=1; a<contador; ++a)
for(b=contador-1; b>=a; --b)
{
if(B[b-1] > B[b])
{
t= B[b-1];
B[b-1] = B[b];
B[b] = t;
}
}
}
Figura 1: Algoritmo BUBLESORT
Características:
Operações Relevantes: comparação;
Expressão: Pior caso – (N-1)*(N-1) = N²-2N+1;
Complexidade: O(n²).
Descrição:
Varrendo do primeiro ao último elemento do vetor, são comparados os seus
valores, dois a dois, e caso o primeiro seja maior que o primeiro eles trocam de lugar no
vetor. A cada varredura se existir um elemento fora da ordem crescente sua posição vai
sendo trocada até ele ficar posicionado corretamente. A varredura é executada a
quantidade de elementos de vezes.
Página 4 de 23

ALGORITMO MERGESORT
void merge(int M[TAMVETOR], int p, int r)
{
int q;
if (p<r)
{
q=((p+r)/2);
merge(M,p,q);
merge(M,q+1,r);
intercala(M,p,q,r);
}
}
void intercala(int M[TAMVETOR], int p, int q, int r)
{
int prim, res, seg, k;
int C[TAMVETOR];
prim = res = p;
seg = q+1;
while(prim<=q && seg<=r)
{
if(M[prim]<=M[seg])
{
C[res] = M[prim];
prim++;
}
else
{
C[res] = M[seg];
seg++;
}
res++;
}
if(prim>q)
for(k=seg; k<=r; k++)
{
C[res] = M[k];
res++;
}
else
for(k=prim; k<=q; k++)
{
C[res] = M[k];
res++;
}
for(k=p; k<=r; k++)
M[k] = C[k];
}
Figura 2: Algoritmo MERGESORT
Características:
Expressão: Pior caso – [N+2*(N/2)+4*(N/4)+8*(N/8)...+N*(N/N)] para
M termos => N*M = N*LOG(N);
Complexidade: O(n*Log(n)).
Descrição:
O vetor de elementos é divido em pares de elementos e então os pares são
ordenados, depois são agrupados de dois em dois pares e então os valores do grupo são
ordenados. O processo de agrupamento ocorre até voltar ao tamanho do vetor original e
nesse ponto o vetor já estará ordenado.
Página 5 de 23

ALGORITMO QUICKSORT
void quick(int Q[TAMVETOR], int inicio, int fim)
{
int meio;
if (inicio<fim)
{
meio = particiona(Q, inicio, fim);
quick(Q, inicio, meio-1);
quick(Q, meio+1, fim);
}
}
int particiona(int Q[TAMVETOR], int inicio, int fim)
{
int pivo,ultbaixo,temp,i;
pivo = Q[inicio];
ultbaixo = inicio;
for(i=inicio+1; i<=fim; i++)
{
if (Q[i]<=pivo)
{
ultbaixo++;
temp = Q[i];
Q[i] = Q[ultbaixo];
Q[ultbaixo] = temp;
}
}
temp = Q[inicio];
Q[inicio] = Q[ultbaixo];
Q[ultbaixo] = temp;
return(ultbaixo);
}
Figura 3: Algoritmo QUICKSORT
Características:
Expressão: Pior caso – [N+2*(N/2)+4*(N/4)+8*(N/8)...+N*(N/N)] para
M termos => N*M = N*LOG(N);
Complexidade: O(n*Log(n)).
Descrição:
Um dos elementos do vetor, segundo um critério, é eleito como pivô. Com isso o
vetor fica dividido em duas partes, então é varrida e são executadas trocas nessas duas
partes de modo que de um lado só existam valores menores que o pivô e do outro só
maiores. Após isso o pivô já se encontra na posição correta no vetor então são eleitos
dois pivôs, um em cada uma das partes do passo anterior e então o processo se repete
até que não tenha mais como eleger um pivô que já não esteja na posição correta,
quando chegar nessa situação o vetor estará ordenado.
Página 6 de 23

ALGORITMO SELEÇÃO
void selecao(int S[TAMVETOR], int contador)
{
register a, b, c;
int exchange;
int t;
for(a=0; a<contador-1; ++a)
{
exchange = 0;
c = a;
t = S[a];
for(b=a+1; b<contador; ++b)
{
if(S[b]<t)
{
c = b;
t = S[b];
exchange = 1;
}
}
if(exchange)
{
S[c] = S[a];
S[a] = t;
}
}
}
Figura 4: Algoritmo SELEÇÃO
Características:
Expressão: Pior caso – (N-1)+(N-2) +(N-3)+...+3+2+1 = N*(N-1)/2;
Descrição:
É feita a procura do menor elemento de todo e então este elemento é trocado de
lugar o primeiro elemento do vetor. Então a procura pelo menor número é feita a partir
do segundo elemento e é trocado de lugar com o segundo elemento do vetor, e assim
sucessivamente até o penúltimo elemento e então o vetor estará ordenado.
Página 7 de 23

ALGORITMO INSERÇÃO
void insercao(int I[TAMVETOR], int contador)
{
register int a, b;
int t;
for(a=1; a<contador; ++a)
{
t = I[a];
for(b=a-1; b>=0 && t<I[b]; b--)
I[b+1] = I[b];
I[b+1] = t;
}
}
Figura 5: Algoritmo INSERÇÃO
Características:
Expressão: Pior caso – (N-1)+(N-2) +(N-3)+...+3+2+1 = N*(N-1)/2;
Descrição:
O vetor é dividido em dois segmentos, um com os elementos já ordenados e o
outro com os elementos a ordenar. No início só o primeiro elemento está no segmento já
ordenado, então é verificado qual a posição do primeiro elemento do segmento a
ordenar no segmento já ordenado, então o elemento é retirado do segmento a ordenar e
inserido no já ordenado. Esse processo se repete até que não exista segmento a ordenar
o que coincide com a ordenação do vetor.
Página 8 de 23

RESULTADOS
Os testes dos algoritmos foram executados por meio de um programa de
computador codificado em linguagem C adaptado de uma versão desenvolvida por UFB
[2]. O programa contém os cinco algoritmos de ordenação analisados nesse trabalho e
são submetidos de cinco mil a cem mil dados, em um passo crescente de cinco mil
dados. Esses dados são gerados de três formas, dados aleatório, dados crescente e dados
decrescentes, e cada algoritmo ordena cada uma dessas três formas. Para minimizar os
erros impostos pelo sistema, o computador, cada vetor de dados é ordenado 10 vezes
por cada algoritmo. Dessas ordenações, o programa coleta a quantidade operações
abstratas executadas, comparação e atribuição; e também o tempo gasto para o vetor ser
ordenado; por cada algoritmo, para cada quantidade de dados de entrada e para cada
tipo de ordenação de dados. Então é gerado um arquivo com a média de cada um dessas
informações.
COMPARAÇÃO DE QUANTIDADES DE OPERAÇÕES
Os gráficos nas figuras 21 a 25, evidenciam que as ordens teóricas são válidas
quando se analisa a média de comportamento dos algoritmos, pois na figura 7 houve
mudança no comportamento dos algoritmos, influenciada pela ordenação dos dados de
entrada. E ao analisar as figuras de 6 a 25, percebe-se que o comportamento da operação
comparação na média fica mais próxima da curva média da ordem do algoritmo.
No aspecto da quantidade de operações executadas também foi comprovado que
os algoritmos com complexibilidade O(n*Log(n)) são mais eficientes no caso médio,
pois quando se compara as figuras 6 e 19 verifica-se que quando os dados estão
ordenados o método BUBLESORT de ordem O(n²) executa menos operações de
comparações que o método QUICKSORT que tem ordem O(n*Log(n)). Porém quando
é analisado a ordenação inicial aleatória dos dados de entrada, que melhor caracteriza o
caso médio, o comportamento de todos os métodos foram condizentes com as premissas
teóricas, variando somente por um fator multiplicativo positivo, fato esse abordado na
teoria.
Página 9 de 23

COMPARAÇÃO DE TEMPO DE ORDENAÇÃO
O estudo de desempenho de algoritmos em função do tempo de execução esta
limitado a um estudo parcial, devido a forte influência de variáveis como tempo de
processamento, técnica de processamento, estabilidade do processamento, eficiência da
codificação, eficiência do compilador, entre outros. Para tentar minimizar alguns desses
limitantes foram coletadas dez informações de tempo de cada vetor ordenado e extraído
a média aritmética. E apesar de na teoria não refletir com precisão o comportamento dos
algoritmos, devido aos cuidados tomados, as figuras 26 a 31 mostram que para este
experimento a análise de tempo foi coerente com a análise de operações executadas.
Comparando as figuras 21 a 25, que são os gráficos de análise de operações
executadas, com as figuras 26 a 31, que são os gráficos de análise de tempo de
ordenação, é evidenciado a equivalência de comportamento em função da ordenação
inicial do vetor de entrada, e com isso novamente é verificado a maior eficiência dos
algoritmos de ordem O(n*Log(n)), também no quesito tempo.
GRÁFICOS
Cabem algumas considerações referentes aos gráficos a seguir.
As curvas intituladas “Teórico O(...” nos gráficos, referem-se as curvas das
ordens teóricas dos algoritmos, e elas auxiliam na comparação do comportamento dos
algoritmos na prática com os seus comportamentos teóricos, porém é necessário atentar-
se ao fato de que as curvas “Teórico O(...” tem coeficientes um (1) quando for feita a
comparação.
As disposições dos nomes das curvas seguem a disposição das mesmas nos
gráficos, evitando a sobreposição dos nomes às linhas, assim quando existem duas ou
mais curvas próximas seus nomes estarão abaixo delas, deslocados na horizontal e
também com a posição na vertical deslocada de modo que o nome mais acima é
respectivo à curva mais acima e assim respectivamente. Quando existem curvas
sobrepostas seus nomes vêm alinhados na horizontal e um abaixo do outro.
Para melhorar a visualização das curvas nas figuras 15, 16, 17, 18, 19, 20, 24,
25, 29, 30, 31 têm seus eixos verticais em escalas logarítmicas e, por isso, sofrem erros
de ajuste. Assim as informações das equações das curvas de tendência têm seus valores
influenciados pela alteração da escala do eixo e apesar das curvas representarem
Página 10 de 23

Página 11 de 23
corretamente o comportamento dos algoritmos, suas equações não refletem a realidade
por causa dos ajustes impostos pelas características do gráfico
Dos gráficos são extraídas informações como:
Operações relevantes: Ao comparar o comportamento dos gráficos do mesmo
algoritmo, nos diferentes métodos de ordenação inicial dos dados de entrada, para cada
tipo de operação abstrata;
Sensibilidade à ordenação dos valores iniciais de entrada: Ao comparar o
comportamento das curvas de quantidade de operação de comparações, do mesmo
algoritmo nos diferentes métodos de ordenação inicial dos dados de entrada;
Ordem do Algoritmo: Equação da curva de quantidade de operação de comparações, de
cada algoritmo nos diferentes métodos de ordenação inicial dos dados de entrada;
Comparativo de desempenho em função de operações executadas: Comportamento da
curva de quantidade de operação de comparações, no mesmo método de ordenação
inicial dos dados de entrada, para os diferentes algoritmos;
Comparativo de desempenho em função do tempo gasto para ordenar: Comportamento
da curva de tempo gasto, no mesmo método de ordenação inicial dos dados de entrada,
para os diferentes algoritmos.

ANÁLISEDECOMPORTAMENTOEDESEMPENHODEALGORITMOSDEORDENAÇÃO
Operaçõesabstratas
Figura6:BUBLESORT-OperaçõesxQt.Dados(Aleatórios)Figura7:BUBLESORT-OperaçõesxQt.Dados(Crescentes)
Figura8:BUBLESORT-OperaçõesxQt.Dados(Decrescentes)
Página12de23

y=14998x
R
2
=1
y=9998,6x
R
2
=1
y=4999,3x
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
OperaçõesAbstratas
Total
Atribuições
Comparações
TeóricoO(n²)
Figura9:INSERÇÃO-OperaçõesxQt.Dados(Aleatórios)Figura10:INSERÇÃO-OperaçõesxQt.Dados(Crescentes)
y=1,0012x
1,9999
R
2
=1
y=0,5003x
1,9999
R
2
=1
0,00E+00
1,00E+09
2,00E+09
3,00E+09
4,00E+09
5,00E+09
6,00E+09
7,00E+09
8,00E+09
0,0E+001,0E+042,0E+043,0E+044,0E+045,0E+046,0E+047,0E+048,0E+049,0E+04
Quantidadededados
Total
Atribuições
Comparações
TeóricoO(n²)
Figura11:INSERÇÃO-OperaçõesxQt.Dados(Decrescentes)
Página13de23

y=124365x
1,0819
R
2
=0,9998
y=1E+07x
1,9975
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n²)
y=0,5003x
2
R
2
=1
y=x-1
R
2
=1
0,00E+00
2,00E+09
4,00E+09
6,00E+09
8,00E+09
1,00E+10
1,20E+10
0,0E+002,0E+044,0E+046,0E+048,0E+041,0E+051,2E+05
Quantidadededados
Total
Atribuições
Comparações
TeóricoO(n²)
Figura12:SELEÇÃO-OperaçõesxQt.Dados(Aleatórios)Figura13:SELEÇÃO-OperaçõesxQt.Dados(Crescentes)
y=1,2515x
1,9999
R
2
=1
y=0,7512x
1,9999
R
2
=1
y=0,5003x
1,9999
R
2
=1
0,00E+00
1,00E+09
2,00E+09
3,00E+09
4,00E+09
5,00E+09
6,00E+09
7,00E+09
8,00E+09
9,00E+09
1,00E+10
0,0E+001,0E+042,0E+043,0E+044,0E+045,0E+046,0E+047,0E+048,0E+049,0E+04
Quantidadededados
Total
Atribuições
Comparações
TeóricoO(n²)
Figura14:SELEÇÃO-OperaçõesxQt.Dados(Decrescentes)
Página14de23

y=138112x
1,0899
R
2
=1
y=67339x
1,0919
R
2
=1y=18684x
1,0987
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n*Log(n))y=114400x
1,0823
R
2
=1y=67339x
1,0919
R
2
=1y=47072x
1,068
R
2
=1y=18684x
1,0987
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n*Log(n))
Figura15:MERGESORT-OperaçõesxQt.Dados(Aleatórios)Figura16:MERGESORT-OperaçõesxQt.Dados(Crescentes)
y=112337x
1,0847
R
2
=1
y=67285x
1,0925
R
2
=1y=45061x
1,0726
R
2
=1y=18657x
1,0997
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
QuantidadedeDados
Total
Atribuições
Comparações
Teórico
Figura17:MERGESORT-OperaçõesxQt.Dados(Decrescentes)
Página15de23

y=18684x
1,0987
R
2
=1
y=78366x
1,109
R
2
=0,9992
y=136737x
1,0746
R
2
=0,9963
y=215104x
1,0876
R
2
=0,9981
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n*Log(n))
y=1E+07x
1,9994
R
2
=1
y=18684x
1,0987
R
2
=1
y=24996x
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n*Log(n))
Figura18:QUICKSORT-OperaçõesxQt.Dados(Aleatórios)Figura19:QUICKSORT-OperaçõesxQt.Dados(Crescentes)
y=3E+07x
1,9997
R
2
=1y=2E+07x
1,9996
R
2
=1y=1E+07x
1,9998
R
2
=1
y=18657x
1,0997
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
Total
Atribuições
Comparações
TeóricoO(n*Log(n))
Figura20:QUICKSORT-OperaçõesxQt.Dados(Decrescentes)
Página16de23

y=0,4997x
2
R
2
=1
0,00E+00
2,00E+09
4,00E+09
6,00E+09
8,00E+09
1,00E+10
1,20E+10
0,0E+002,0E+044,0E+046,0E+048,0E+041,0E+051,2E+05
Quantidadededados
Quantidadedeoperaçõesdecomparação
Aleatórios
Crescentes
Decrescentes
TeóricoO(N²)
y=2E+07x
2
R
2
=1
y=1E+07x
1,9999
R
2
=1
y=6E+06x
2,0006
R
2
=1y=4999,3x
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
Aleatórios
Crescentes
Decrescentes
TeóricoO(N²)
Figura21:BUBLESORT-ComparaçãoxQt.DadosFigura22:INSERÇÃO-ComparaçãoxQt.Dados
y=0,5003x
2
R
2
=1
0,00E+00
2,00E+09
4,00E+09
6,00E+09
8,00E+09
1,00E+10
1,20E+10
0,0E+002,0E+044,0E+046,0E+048,0E+041,0E+051,2E+05
Quantidadededados
Aleatórios
Crescentes
Decrescentes
TeóricoO(N²)
Figura23:SELEÇÃO-ComparaçãoxQt.Dados
Página17de23

y=70774x
1,088
R
2
=1
y=47072x
1,068
R
2
=1y=18684x
1,0987
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
QuantidadedeDados
Aleatórios
Crescentes
Decrescentes
TeóricoO(n*Log(n))
y=1E+07x
1,9998
R
2
=1
y=78366x
1,109
R
2
=0,9992y=18684x
1,0987
R
2
=1
1,00E+00
1,00E+01
1,00E+02
1,00E+03
1,00E+04
1,00E+05
1,00E+06
1,00E+07
1,00E+08
1,00E+09
1,00E+10
QuantidadedeDados
Aleatórios
Crescentes
Decrescentes
Teórico
Figura24:MERGESORT-ComparaçãoxQt.DadosFigura25:QUICKSORT-ComparaçãoxQt.Dados
Página18de23

y=0,4291x
2,119
R
2
=0,9967
y=0,1559x
2,0843
R
2
=0,9986
y=0,1605x
2,1844
R
2
=0,9928
1,00E-01
1,00E+00
1,00E+01
1,00E+02
1,00E+03
QuantidadedeDados
Tempo(seg)
BubleSort
Seleção
Inserção
Tempo(seg)
Figura26:AlgoritmosO(n²)-TempoxQt.Dados(Aleatórios)Figura27:AlgoritmosO(n²)-TempoxQt.Dados(Crescentes)
Tempo(seg)
Figura28:AlgoritmosO(n²)-TempoxQt.Dados(Decrescentes)
Página19de23

Tempo(seg)
Tempo(seg)
Figura29:AlgoritmosO(n*Log(n))-TempoxQt.Dados(Aleatórios)Figura30:AlgoritmosO(n*Log(n))-TempoxQt.Dados(Crescentes)
Tempo(seg)
Figura31:AlgoritmosO(n*Log(n))-TempoxQt.Dados(Decrescentes)
Página20de23

Página 21 de 23
CONCLUSÕES
A escolha do melhor algoritmo não se fixa simplesmente em buscar o algoritmo
que seja mais eficiente na média, para uma boa análise é necessário saber os domínios
do problema, verificando quantidade de informações envolvidas no problema e também
se existe alguma pré-ordenação nas mesmas.
A determinação de velocidade de execução é inerente a cada sistema, por causa
das muitas variáveis que interferem na execução do programa, é possível ter uma idéia
de tempo em função da velocidade do processador, porém é mais preciso quando se
executa um teste de desempenho do algoritmo na máquina para determinar o tempo
gasto.
As variáveis de quantidade de dados e pré-ordenação influenciam drasticamente
no desempenho dos algoritmos testados.
A correta determinação da operação relevante de um algoritmo é essencial para
prever o comportamento do algoritmo e determinação de sua ordem, garantindo assim
uma analise prévia de como o algoritmo irá comportar perante um problema sem a
necessidade de testes.
A ordem de um algoritmo é uma informação fundamental para avaliação de
viabilidade de um algoritmo em um determinado problema, e o conhecimento das
ordens de diversos algoritmos é uma ferramenta fundamental para se fazer uma boa
análise do algoritmo que se pretende empregar.

Página 22 de 23
ÍNDICE DE FIGURAS
Figura 1: Algoritmo BUBLESORT .......................................................................................4
Figura 2: Algoritmo MERGESORT ......................................................................................5
Figura 3: Algoritmo QUICKSORT........................................................................................6
Figura 4: Algoritmo SELEÇÃO ............................................................................................7
Figura 5: Algoritmo INSERÇÃO ..........................................................................................8
Figura 6: BUBLESORT - Operações x Qt.Dados(Aleatórios)............................................12
Figura 7: BUBLESORT - Operações x Qt.Dados(Crescentes) ...........................................12
Figura 8: BUBLESORT - Operações x Qt.Dados(Decrescentes)........................................12
Figura 9: INSERÇÃO - Operações x Qt.Dados(Aleatórios) ...............................................13
Figura 10: INSERÇÃO - Operações x Qt.Dados(Crescentes)...........................................13
Figura 11: INSERÇÃO - Operações x Qt.Dados(Decrescentes).......................................13
Figura 12: SELEÇÃO - Operações x Qt.Dados(Aleatórios) .............................................14
Figura 13: SELEÇÃO - Operações x Qt.Dados(Crescentes).............................................14
Figura 14: SELEÇÃO - Operações x Qt.Dados(Decrescentes).........................................14
Figura 15: MERGESORT - Operações x Qt.Dados(Aleatórios) .......................................15
Figura 16: MERGESORT - Operações x Qt.Dados(Crescentes) ......................................15
Figura 17: MERGESORT - Operações x Qt.Dados(Decrescentes)...................................15
Figura 18: QUICKSORT - Operações x Qt.Dados(Aleatórios).........................................16
Figura 19: QUICKSORT - Operações x Qt.Dados(Crescentes)........................................16
Figura 20: QUICKSORT - Operações x Qt.Dados(Decrescentes)....................................16
Figura 21: BUBLESORT - Comparação x Qt.Dados........................................................17
Figura 22: INSERÇÃO - Comparação x Qt.Dados ...........................................................17
Figura 23: SELEÇÃO - Comparação x Qt.Dados .............................................................17
Figura 24: MERGESORT - Comparação x Qt.Dados .......................................................18
Figura 25: QUICKSORT - Comparação x Qt.Dados ........................................................18
Figura 26: Algoritmos O(n²) - Tempo x Qt.Dados(Aleatórios).........................................19
Figura 27: Algoritmos O(n²) - Tempo x Qt.Dados(Crescentes) ........................................19
Figura 28: Algoritmos O(n²) - Tempo x Qt.Dados(Decrescentes).....................................19
Figura 29: Algoritmos O(n*Log(n)) - Tempo x Qt.Dados(Aleatórios).............................20
Figura 30: Algoritmos O(n*Log(n)) - Tempo x Qt.Dados(Crescentes) ............................20
Figura 31: Algoritmos O(n*Log(n)) - Tempo x Qt.Dados(Decrescentes).........................20

Página 23 de 23
REFERÊNCIAS
BIBLIOGRÁFICAS
[1] PASSARO, A. – Apostilas de Projeto e análise de algoritmo e notas de aula;
[2] UFB – Programa desenvolvido por alunos da Universidade Federal da Bahia;
[3] http://www.inf.unisinos.br/~marcelow/ensino/grad/lab2/semana15.html
[4] http://www.ime.usp.br/~pf/analise_de_algoritmos/aulas/mergsrt.html

Análise de desempenho de algoritmos de ordenação

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Análise de desempenho de algoritmos de ordenação

Semelhante a Análise de desempenho de algoritmos de ordenação (20)

Análise de desempenho de algoritmos de ordenação