UNIVERSIDADE FEDERAL DO VALE DO SO FRANCISCO UNIVASF

COLEGIADO DE ENGENHARIA DA COMPUTAO CECOMP

RELATRIO DE COMPLEXIDADE DE TEMPO E ESPAO DE ALGORITMOS

Equipe: Rafael Gonalves,

Romullo Abizair,
Saulo Rogrio.

Juazeiro BA
Dezembro de 2013

UNIVERSIDADE FEDERAL DO VALE DO SO FRANCISCO UNIVASF

COLEGIADO DE ENGENHARIA DA COMPUTAO CECOMP

RAFAEL GONALVES, ROMULLO ABIZAIR, SAULO ROGRIO.

RELATRIO DE COMPLEXIDADE DE TEMPO E ESPAO DE ALGORITMOS

Relatrio desenvolvido para a

disciplina Estrutura de Dados II,
ministrada pela professora
Ana Emlia Melo Queiroz e
usado como critrio de avaliao.

Juazeiro BA
Dezembro de 2013

ndice

1. Introduo ........................................................................................................................ 4
2. Esquema Bsico de um Algoritmo ................................................................................... 5
3. Tamanho da Entrada ........................................................................................................ 6
4. Tempo de Complexidade de um Algoritmo .................................................................... 6
4.1 Anlise do Tempo ...................................................................................................... 6
4.2 Anlise do Pior, Mdio e Melhor casos ...................................................................... 7
4.3 Algoritmos de Ordenao ........................................................................................... 7
4.4 Comportamento das Funes de Tempo ................................................................... 11
4.5 A Anlise Matemtica e Emprica .............................................................................. 12
4.6 Grficos Melhor, Mdio e Pior casos ......................................................................... 13
4.7 Resultados da Implementao das Anlise Matemtica e Emprica .......................... 16
4.8 Limite Inferior e Limite Superior ............................................................................... 16
4.9 A eficincia dos Algoritmos na Obteno dos Resultados ......................................... 16
5. Espao de Complexidade de um Algoritmo ....................................................................... 17
6. Concluso ............................................................................................................................ 18
7. Referncias Bibliogrficas .................................................................................................. 18

1. Introduo
Assim como fala [ZIVIANI, 1999], os algoritmos fazem parte do nosso dia-dia.
Instrues, receitas, manuais so exemplos de algoritmos.
Algoritmo de modo resumido um conjunto sequencial e finito de aes que devem ser
executadas para se chegar num objetivo, ou seja, passos necessrios para se chegar a uma
resoluo de um determinado tipo de problema. Mas, como para cada problema tm-se uma
resoluo, encontramos uma incgnita aqui. Podemos ter uma ou vrias resolues para um
mesmo problema por exemplo, e tambm cada cdigo ter uma complexidade e um tempo
de execuo para se chegar ao objetivo, ou seja, cada algoritmo ter sua sequncia de passos
e seu tamanho, diferenciando assim de uma outra resoluo.
J de acordo com [LEISERSON,2002] algoritmo nada mais do que uma receita que mostra
passo a passo os procedimentos necessrios para a resoluo de uma tarefa. Com isso,
[LEISERSON,2002] aprofunda-se mais um pouco ao dizer que estrutura de dados est
ligada escolha do melhor algoritmo para a resoluo de uma tarefa, da levamos em conta
questes como o armazenamento e organizao dos dados, assim mostramos que estamos
preocupados com o melhor modo para se chegar ao objetivo, o jeito mais rpido e fcil de se
resolver um problema. Existem vrios tipos de estruturas de dados e nenhuma delas
funciona perfeitamente para todos os problemas requisitados, com isso, importante no s
conhecer cada uma delas mais tambm escolher melhor aquela que ir proporcionar um
desempenho satisfatrio.
Como algoritmos estruturados so organizadamente escritos, no tem como
falarmos de estrutura de dados sem mencionar os algoritmos e suas caractersticas, nem
como escrever um algoritmo sem pensar em sua estrutura. De acordo com [ZIVIANI, 1999],
programar basicamente construir um cdigo e estrutura-lo adequadamente, de acordo com
as necessidades dos usurios.
Mesmo que os computadores atuais tenha configuraes boas, as mquinas ainda
tem suas limitaes, talvez sua memria seja absurdamente grande, mas certas tarefas ainda
levam muito tempo para serem executadas. Se tivssemos um super computador que fosse
capaz de executar suas aes incrivelmente rpidos, ns no precisaramos nos preocupar
com a estruturao de algoritmos para solucionar problemas, porque todos os algoritmos

teriam seus resultados iguais, e utilizaramos sempre o mtodo mais rpido e fcil de ser
implementado. Por isso devemos dar ateno a importncia de criar algoritmos eficientes em
termos de tempo e de espao alocado na memria para assim termos os melhores resultados
possveis.

2. Esquema Bsico de um Algoritmo

Como j mencionamos anteriormente, os algoritmos so como espcies de
receitas, nas quais tm-se os passos necessrios para se realizar uma tarefa. O ideal que
esse passo a passo seja claro e objetivo, sem ser ambguo ou redundantes.
Os algoritmos podem ser construdos atravs de uma linguagem chamada pseudocdigo, que
tem uma formatao e estrutura mais prxima da escrita humana, ajudando assim aos
iniciantes na programao. Evidenciando-se que um algoritmo independe de linguagens de
programao. Em pseudocdigo, o algoritmo posteriormente servir como uma ponte para
uma linguagem de programao mais desenvolvida e objetiva.
Segundo [VILLAR, 1993], temos algumas regras que so importantes na construo de um
algoritmo. So elas:

Ser objetivo

Supor que voc est desenvolvendo um algoritmo para pessoas que no trabalham
conhecem informtica

Utilizar frases simples e curtas

Usar um verbo por frase

Usar palavras que no tenham um sentido difcil de se entender ou definir

O esquema da figura abaixo ilustra independente de sua complexidade, como os algoritmos

so implementados:

3. Tamanho da Entrada
O tamanha da entrada a quantidade de valores iniciais que sero implementados
e testados nos algoritmos. Dependendo do tipo ou estrutura do algoritmo, uma ordenao de
valores num algoritmo pode ser simples ou complexa, mostrando assim que devemos nos
preocupar em escolher melhor a estrutura para uma determinada quantidade de entrada. Em
alguns casos os algoritmos de ordenao mais simples tero uma maior eficincia que os
mais complexos, como o MergeSort que usa a recursividade em alguns problemas, e como
esta tcnica tem um alto consumo de memria e tempo de execuo, acaba no sendo muito
eficiente mesmo tendo uma complexidade de tempo menor (MergeSort (n log2 n)). Mas
isso no significa que ele ser mais eficiente que um InsertionSort, que tem sua
complexidade de tempo (n2).

4. Tempo de Complexidade de um Algoritmo

4.1 Anlise de Tempo
[ZIVIANI,2004] revela que uma das problemticas que tem que ser resolvida pelo
projetista a questo da anlise do tempo de execuo de um dado algoritmo, que pode ser medido
diretamente, apesar de ser considerada uma medida inadequada, por depender do compilador, do
hardware, utilizao de memria, serve para casos particulares, onde existem vrios algoritmos para
um mesmo problema. A forma mais adequada, seria o uso da funo de complexidade, onde
possvel ignorar o custo de algumas operaes envolvidas, que venham a ser irrelevantes. Esta

anlise importante, para desenvolver solues mais rpidas, e que gastem menos recursos do
computador, poupando memria por exemplo.

4.2 Anlise do Pior, Mdio e Melhor Casos

Segundo [MARCO, 2001] em sua dissertao, deixa transparecer que:

Anlise no pior caso.

Refere-se ao nmero mximo de operaes fundamentais que devem ser feitas para a
resoluo de qualquer problema do tamanho fixado.
Pode ser considerado como um limite de complexidade que no ser ultrapassado, sendo
portanto, uma garantia de qualidade mnima do algoritmo. Sua desvantagem que os casos
caticos que dificilmente vo acontecer so levados em considerao, nessa anlise.

Anlise no Caso Mdio

mais difcil de determinar do que a complexidade no pior caso. Porque baseia-se nas
distribuies probabilsticas dos dados de entrada do algoritmo, que nem sempre so
conhecidas. Esta anlise indicada para algoritmos que so utilizados com frequncia.
Os algoritmos que no possuem nenhuma estrutura condicional apresentam complexidades
no pior caso e caso mdio, iguais, porque ser executada, sempre o mesmo nmero de
operaes para um mesmo tamanho de entrada.

Anlise no melhor caso

De acordo com [ZIVIANI,2004], o melhor caso dado a partir do menor tempo de

execuo sobre todas as entradas de tamanho n.

4.3 Algoritmos de Ordenao

4.3.1 BubbleSort
o mtodo mais simples em termos de implementao, porm o
menos eficiente. A idia principal do algoritmo percorrer o vetor n 1 vezes, a cada
passagem fazendo flutuar para o incio o menor elemento da sequncia. Essa movimentao,
percorrendo o array fazendo comparaes e trocas sucessivas lembra a forma como as
bolhas procuram seu pulam de um nvel para o outro, por isso o nome do algoritmo.

Seu uso no recomendado para vetores com muitos elementos.

Este mtodo pode ser melhorado devido questo de que os

elementos nas posies acima ou iguais a n - i j esto na ordem correta depois da iterao i,
(ou seja cada iterao garante que pelo menos mais um elemento encontrou a posio
desejada)por isso eles no precisam ser considerados nas prximas iteraes. Dessa maneira,
na primeira vez q o algoritmo percorre o array, s feita a comparao entre os dois
primeiros elementos. [TENEBAUM, 1995]. O melhor caso quando utilizamos este mtodo
se d apenas quando o arquivo est completamente ordenado, fazendo n 1 comparaes e
nenhuma troca, percorrendo o array uma nica vez. Encontramos o Pior caso quando o array
est em ordem reversa, ou seja, quando o ksimo passo faz n - k comparaes e trocas,
sendo necessrio n 1 passos.
Um dado curioso a cerca da ineficincia deste mtodo acontece quando o array est
praticamente ordenado e apenas o menor dos elementos est na ltima posio. Desta
maneira o ser realizado o mesmo nmero de comparaes do pior caso.
4.3.2 InsertionSort
Segundo [QUEIROZ, 2009], a classificao por insero um mtodo
in place que separa o vetor de entrada em dois subvetores, movendo os registros do subvetor
no-ordenado para o vetor ordenado, sendo o ltimo acrescido de um elemento a cada
iterao. [ZIVIANI, 2004] comenta que em cada passo, a partir de i=2, o i-simo item do
vetor no-ordenado apanhado e inserido no seu lugar apropriado dentro do vetor ordenado.

Esse um dos mtodos mais utilizados entre os jogadores de cartas, por ser fcil de ser
implementado. A complexidade do algoritmo da ordem O(n) [ZIVIANI, 2004].
4.3.3 SelectionSort
De acordo com Ziviani, um dos mtodos de ordenao mais simples,
possui um tempo de execuo linear no tamanho de entrada. Quando o arquivo j est
ordenado o custo quadrtico. um mtodo interessante para arquivos pequenos.
4.3.4 ShellSort
[ZIVIANI, 2004] explica que o shellsort uma extenso do algoritmo
de ordenao por insero. Entretanto, na classificao por insero, se o menor item do
vetor de origem estiver na posio mais direita, ento o nmero de comparaes e
movimentaes igual a (n-1) para encontrar o seu ponto de insero.
A estratgia utilizada pelo shellsort para contornar este problema foi permitir trocas de
registros que esto distantes um do outro. Os itens que esto separados h posies so
rearranjados de tal forma que todo h-simo item leva a uma sequncia ordenada.
Alguns autores chamam h de salto, que pode ser constante ou pode variar de acordo com
uma lgica previamente escolhida. Vrias sequncias para h tm sido experimentadas.
[KNUTH, 1973] mostrou experimentalmente que a escolha do incremento para h = {1, 4,
13, 40, 121, 364, 1093, 3280, ...} difcil de ser batida por mais de 20% em eficincia no
tempo de execuo.
Shellsort uma tima opo para arquivos de tamanho moderado (da ordem de 5000
registros), segundo ZIVIANI, tanto pela fcil implementao do cdigo como pelo tempo de
classificao.
Quanto sua complexidade, existem duas conjecturas tratadas por ZIVIANI: C(n) =
O(n1,25) e C(n) = O(n*log2(n)). O autor explica que o algoritmo possui em sua
complexidade problemas matemticos difceis de resolver e ningum conseguiu prov-la
ainda.
4.3.5 QuickSort
Consiste em dividir o problema de ordenar um conjunto de n itens em
2 problemas menores, os problemas menores so ordenados e depois os resultados so
combinados para produzir a soluo do maior problema. (Dividir para conquistar !) Este
mtodo ineficiente para arquivos j ordenados com piv inadequado, pois as parties

sero desiguais , e a funo de ordenao ser chamada n vezes, sendo que em cada uma
dessas s conseguir eliminar um item por chamada, fazendo com que o nmero de
comparaes passe a ser cerca de n2/2. O melhor caso acontece quando o arquivo dividido
em duas partes iguais, este mtodo requer uma pequena pilha, que servir como memria
auxiliar, e ordenar um vetor com n itens, com cerca de nlog n operaes.
4.3.6 MergeSort
O conceito de merging ou fundir complementar ao conceito de
selecionar, visto anteriormente, quando se trata de algoritmos de ordenao. [SEDGEWICK,
1998] trata do termo como combinar dois arquivos [vetores] ordenados para formar um
maior que os anteriores tambm ordenado. Esse conceito faz parte da ideia de dividir e
conquistar, muito utilizado na ordenao de registros.
No caso do merge sort, a diviso feita utilizando recursividade, armazenando os dados do
vetor original na pilha em forma de rvore binria, segundo [Queiroz, 2009]. Aps a diviso,
cada subvetor ordenado recombinado com outro intercalando os elementos, mantendo-se a
ordenao. Esse algoritmo considerado de ordenao externa, pois se utiliza de outro
espao da memria para efetuar a classificao.
[SEDGEWICK, 1998] ainda trata de alguns fatores que tornam o merge sort atrativo. Dentre
eles est o fato de que o tempo de execuo para um vetor de n elementos da ordem de
n*log(n). Outro fator observado pelo autor que o algoritmo estvel, o que significa dizer
que independentemente do tamanho da entrada, a sada ser sempre proporcional a n*log(n).
4.3.7 HeapSort
Utilizando o mesmo princpio do SelectSort, o HeapSort um
algoritmo que utiliza uma estrutura de dados conhecida como Heap binrio para manter o
prximo item a ser selecionado. Criado em 1964 por Robert W. Floyd e J.W.J. Williams, ele
um algoritmo de Ordem de Complexidade O(n log n).
Existem dois tipos de heaps: Os heaps de mximo (max heap), em que
o valor de todos os ns so menores que os de seus respectivos pais; e os heaps de mnimo
(min heap), em que o valor de todos os ns so maiores que os de seus respectivos pais.
Assim, em um heap de mximo, o maior valor do conjunto est na raz da rvore, enquanto
no heap de mnimo a raz armazena o menor valor existente. Os heaps podem ser
representados por arranjos, nesse caso a maior (menor) chave est sempre na posio 1 do
array. Os algoritmos para implementar as operaes sobre o heap operam ao longo de um
dos caminhos da rvore, a partir da raiz at o nvel mais profundo da rvore.

10

A figura abaixo mostra um exemplo de um HeapSort:

4.4 Comportamento das Funes de Tempo

[ZIVIANI,2004] Afirma que as funes de tempo so medidas a partir da
complexidade de um dado algoritmo, dadas pela notao do BIG O, cuja notao definida
como um funo g(n) O( f (n)) para alguma constante c > 0 a expresso 0 g(n) cf(n)
vlida.
As principais funes de complexidade:

n f(n) = O(1)

Algoritmos de complexidade O(1) so ditos de complexidade constante.

n f(n) = O(log n)

Um algoritmo de complexidade O(log n) dito ter complexidade logartmica.

Tpico em algoritmos que transformam um problema em outros menores.

n f(n) = O(n)

Um algoritmo de complexidade O(n) dito ter complexidade linear

Cada vez que n dobra de tamanho, o tempo de execuo dobra. n f(n) = O(n log n)

11

Tpico em algoritmos que quebram um problema em outros menores, resolvem cada um

deles independentemente e ajuntando as solues depois.

n f(n) = O(n2)

Um algoritmo de complexidade O(n2) dito ter complexidade quadrtica.

Ocorrem quando os itens de dados so processados aos pares, muitas vezes em um anel
dentro de outro.

n f(n) = O(n3)

Um algoritmo de complexidade O(n3) dito ter complexidade cbica.

teis apenas para resolver pequenos problemas.

n f(n) = O(2n)

Um algoritmo de complexidade O(2n) dito ter complexidade exponencial.

Geralmente no so teis sob o ponto de vista prtico.

n f(n) = O(n!)

Um algoritmo de complexidade O(n!) dito ter complexidade exponencial,

apesar de O(n!) ter comportamento muito pior do que O(2n).
4.5 Anlise Matemtica e Emprica
Anlise emprica baseia-se no desenvolvimento de uma implementao correta e
completa do algoritmo e depende no apenas da natureza dos dados de entrada utilizados
durante a experimentao, mas tambm de outros fatores que tm influncia no
experimento. Como o ambiente de execuo utilizado, considerando as mquinas, os
compiladores e os sistemas utilizados durante os experimentos. Enquanto que a anlise
matemtica uma alternativa anlise emprica, sendo especialmente til quando a anlise
experimental consome uma quantidade significativa de tempo ou quando necessitamos de
alguma indicao de eficincia antes de qualquer investimento de desenvolvimento.
De acordo com [SEDGEWICK,1998], ele comenta que a anlise matemtica pode
trazer mais informaes e ser mais barata que a anlise emprica, que em alguns casos pode
ser suficiente.

12

Com a metodologia utilizada, espera-se obter o tempo mdio da ordenao de um conjunto

de entradas, aplicado aos algoritmos analisados. Assim poderemos comparar a praticidade
com que os algoritmos podem ser utilizados. Devido ao experimentos iniciais de durao
prolongada, foram criados dois conjuntos de entradas para serem executados pelos
algoritmos eficientes e pelos menos eficientes.
Os algoritmos foram subdivididos em dois grupos: 1 Bubble, Selection e Insertion.
2 Quick, Merge, Heap e Shell.
Paro o grupo 1, foi utilizado o seguinte conjunto de entradas em elementos int: 30.000;
60.000;120.000;240.000;480.000 e 960.000
Paro o grupo 2, foi utilizado o seguinte conjunto de entradas em elementos int: 30.000;
60.000;120.000;240.000;480.000;960.000 e 2.000.000
4.6 Grficos do Melhor, Mdio e Pior casos

13

14

15

4.7 Concluses sobre anlise emprica e matemtica

Podemos concluir que medida que o nmero de elementos aumenta, o
desempenho diminui e o tempo em milissegundos, aumenta. Tomando N como o tamanho
do vetor, com exceo dos mtodos, no melhor caso, BubbleSort que verifica se o seu
sucessor maior, e o InsertionSort que verifica se seu antecessor menor, N-1 vezes.
O mtodo que no geral, apresentou o melhor desempenho, foi o ShellSort.
4.8 Limite Inferior e Limite Superior
O limite superior de complexidade diz respeito ao melhor algoritmo conhecido que o
resolva. Enquanto o limite inferior de complexidade diz respeito a quantidade mnima necessria de
recursos para a resoluo do problema.

4.9 Eficincia dos Algoritmos

Cada autor tem seu prprio conceito do que um algoritmo, mais podemos
resumir todos estes conceitos em um, algoritmo nada mais do que uma receita que mostra
passo a passo os procedimentos necessrios para a resoluo de uma tarefa. Em termos mais
tcnicos, um algoritmo uma sequncia lgica, finita e definida de instrues que devem ser
seguidas para resolver um problema ou executar uma tarefa, e com isso vem outra questo,
podem existir inmeros tipos diferentes de procedimentos que levem a resoluo de um
mesmo problema, cada procedimento ter uma complexidade e um tempo de durao para
se chegar ao objetivo, ou seja, cada algoritmo tem sua sequncia prpria de passos e seu
tamanho. Quando levamos em conta as questes como o armazenamento de dados e
Como podemos definir se um algoritmo melhor que o outro assumindo que todos sejam
eficazes, devemos ento verificar qual o mais eficiente. Eficincia pode ser definida como
a capacidade de se atingir um resultado correto, utilizando a menor quantidade de recursos e
tempo possvel. Uma das formas de se analisar o tempo de execuo de um algoritmo
conhecida como anlise assinttica, ou clculo da eficincia assinttica, em que se procura
encontrar uma tendncia no tempo de execuo, quando o volume de dados de entrada do
problema tende ao infinito. Todos esses conjuntos de ferramentas de anlise fazem parte de
uma rea de conhecimento que visa no apenas entender as limitaes dos algoritmos, mas
tambm melhorar a qualidade e a eficincia do software desenvolvido. Todo desenvolvedor
deveria saber utilizar corretamente estas ferramentas e organiza-los de forma coerente,
mostramos que estamos preocupados com o melhor

16

se estes dados esto no caminho para se chegar ao objetivo, que o jeito mais rpido e fcil
de se resolver um problema. Existem vrios tipos de estruturas e nenhuma delas funciona
bem para todos os propsitos, e com isso importante no s conhecer cada uma delas mais
tambm escolher aquela que ir proporcionar um melhor desempenho.
O tipo de estrutura a ser utilizada em um algoritmo est relacionado principalmente
com o tamanho de sua entrada, um exemplo disso o tipo de ordenao que ser
utilizada em uma lista, dependendo do tamanho de itens a serem inseridos na lista a
ordenao poder ser simples, como exemplo o Insertion sort, Selection sort ou
Bubble sort, ou uma ordenao mais complexa como o Quick sort ou Merge sort,
em certos casos os algoritmos de ordenao mais simples tero uma maior eficincia que os
mais complexos, como o Merge sort usa a recursividade em alguns
problemas e est tcnica no muito eficiente devido ao alto consumo de memria e
tempo de execuo, mesmo tendo uma complexidade de tempo menor(Merge sort
(n log2 n)) no significa que ele ser mais eficiente que o Insertion sort que tem a
complexidade de tempo (n2).
Um dos motivos para se preocupar com a melhor estrutura a ser utilizada em um
certo problema que os computadores tm suas limitaes, por mais que os
computadores atuais paream rpidos e sua memria seja absurdamente grande,
certas tarefas levam muito tempo para serem executadas, imagine um computador
que fosse infinitamente rpido, voc no precisaria se preocupar com a estrutura que
escolheu para solucionar seu problema e assim todos os algoritmos capazes de
resolver uma tarefa teriam resultados iguais, assim utilizaramos sempre o mtodo
mais fcil de ser implementado, j que esse computador no existe e nunca vai
existir de extrema importncia criar algoritmos eficientes em termos de tempo e de
espao alocado na memria para assim termos os melhores resultados possveis.

5. Espao de Complexidade de um Algoritmo

Existem dois tipos de utilizao de espao extra, o primeiro quando os
elementos a serem ordenados excedem o tamanho da memria principal, e o segundo
quando necessitamos de um espao, como por exemplo, um vetor extra definido pelo
prprio algoritmo, para possibilitar a realizao das operaes.

17

No nosso caso, no foi utilizado o primeiro tipo (ordenao externa), e o segundo foi
utilizado paraos mtodos de ordenao MergeSort e QuickSort.

6. Concluso
De forma resumida, podemos concluir que, apesar de alguns algoritmos serem
mais eficientes que outros, em um caso especifico podemos mudar esta percepo, no
melhor caso, o BubbleSort tem um melhor desempenho que o QuickSort ou ShellSort. E o
ShellSort, ao observar o comportamento de tempo de execuo, o ShellSort o mais
eficiente.
A partir da anlise matemtica e emprica possvel analisar para qualquer caso o algoritmo
mais adequado. Aps a concluso deste relatrio, seremos capazes de nos preocupar em
poupar memria, e fazer um algoritmo mais eficiente e cada vez mais profissional.

7. Referncias Bibliogrficas

1. SEDGEWICK, Robert, 1946 Algoriths in C / Robert Sedgewick 3rd ed. Reading,

Mass.: Addison Wesley, c1998.
2. TENEMBAUM, Aaron M., LAMNGSAM, Yedidyah,

AUGENSTEIN, Mosha J.;

estruturas de dados Usando C, Pearson Makron Books, 2005.

3. ZIVIANI, Nvio, 2004 Projetos de Algoritmos.
4. QUEIROZ, Ana E., Notas de aula, 2009.

18