CENTRO FEDERAL DE EDUCAO TECNOLGICA

DE MINAS GERAIS

Laboratrio de Algoritmos e Estruturas de dados

Trabalho Prtico 01 - Professora: Cristina Duarte Murta
Nome: Bruno de Araujo Coutinho
Matrcula: 201312040149
Data para entrega: 02/05/2014 (sexta-feira)

EXPERIMENTO 01
Este experimento consiste em medir o tempo de execuo de um programa de complexidades
n, n e n. A complexidade do programa pode ser variada pelo nmero de laos for no mesmo. Foi
utilizado o programa mede_tempo.c, construdo em sala de aula, para a realizao das medies.
As medies foram realizadas em um computador do tipo Desktop com um processador Pentium(R) Dual-Core com 2,3 GHz e memria RAM de 2,00 Gb rodando o sistema operacional
Ubuntu verso 13.10 e o compilador utilizado foi o gcc.
A Tabela 01 abaixo mostra os dados obtidos. O valor de N definido como potncias de 10.
Os resultados obtidos esto medidos em segundos.
Tabela 01: Valores do tempo para as ordens de complexidade
n, n e n em funo do nmero de instrues N executadas
N

O(n)

O(n)

O(n)

1.000e+03

4.550e+00

5.000e+03

5.687e+02

1.000e+04

4.500e-01

4.322e+03

1.000e+05

4.526e+01

**

1.000e+06

4.357e+03

**

1.000e+07

4.000e-02

**

**

1.000e+08

4.500e-01

**

**

1.000e+09

4.530e+00

**

**

1.000e+10

3.941e+01

**

**

* valores muito prximos de zero, no foram possveis de ser medidos.

** valores muito grandes, no foram possveis de serem medidos devido ao enorme tempo de execuo.

Na prxima pgina pode-se ver os grficos relacionados Tabela 01.

ANLISE DO EXPERIMENTO 1
Pode-se perceber que dependendo do nmero de laos for aninhados em um cdigo, tem-se
ordens de complexidade diferentes e, consequentemente, tempos de execuo que variam na mesma ordem de complexidade. Por exemplo, quando tem-se dois laos for, produzimos um cdigo de
complexidade O(n) e, portanto, cada vez que multiplicamos a entrada de dados (N) por 10, o tempo de execuo ser multiplicado por 100 (10), como esperado pela teoria.
Por causa da dificuldade em achar um intervalo no qual o programa mede_tempo.c pudesse
gerar tempos diferentes de zero para os 3 cdigos simultaneamente, optou-se por fazer trs grficos
independentes. Observa-se que para entradas de dadas (N) muito grandes, um algoritmo de ordem

O(n) resolve o problema em um tempo bem menor que algoritmos de ordem O(n) e O(n).
Grficos relativos Tabela 01:

EXPERIMENTO 02
Este experimento prope que se desenvolva um algoritmo capaz de retornar o valor da soma
da maior sequncia consecutiva de elementos em um vetor de inteiros.
PROJETO DO ALGORITMO

Algoritmo MaiorSomaConsecutiva

{ Objetivo: Dada um vetor aleatrio de TAM_VEC elementos, determinar a

sequncia de nmeros do vetor que gera a maior soma possvel. }
parmetros de entrada TAM_VEC, LIM_VEC
parmetros de sada soma_maior
Preencher um vetor de inteiros com elementos aleatrios negativos e
positivos;
Imprimir o vetor gerado;
Determinar a sequncia de nmeros do vetor aleatrio que produz a maior
soma;

fim algoritmo
Refinamento Algoritmo MaiorSomaConsecutiva

{ Objetivo: Dada um vetor aleatrio de TAM_VEC elementos,

determinar a sequncia de nmeros do vetor que gera a
maior soma possvel. }
parmetros de entrada TAM_VEC, LIM_VEC
parmetros de sada soma_maior
Preencher um vetor de inteiros com elementos aleatrios negativos e
positivos;
Imprimir o vetor gerado;
Fixar o primeiro elemento do vetor;
Armazen-lo em soma_maior;
Ir somando o primeiro elemento com os demais. Cada vez que esta soma for
maior que soma_maior, fazer a atribuio;
Fixar o segundo elemento do vetor;
Ir somando o segundo elemento com os demais (2 + 3), (2 + 3 + 4) at
chegar na ltima soma. Cada vez que esta soma for maior que soma_maior,
atribuir a soma soma_maior;
Ir fixando o prximos elementos (3, 4, ) e ir fazendo as somas
consecutivas;
Ao final, em soma_maior estar a maior soma consecutiva dos elementos do
vetor.

fim Refinamento algoritmo

Refinamento Algoritmo MaiorSomaConsecutiva

{ Objetivo: Dada um vetor aleatrio de TAM_VEC elementos, determinar a

sequncia de nmeros do vetor que gera a maior soma possvel. }
parmetros de entrada TAM_VEC, LIM_VEC
parmetros de sada soma_maior
{Gera o vetor aleatrio}
para i 0 at TAM_VEC faa
v(i) nmero aleatrio entre -LIM_VEC e +LIM_VEC
fim para
{Imprime o vetor gerado}
para i 0 at TAM_VEC faa
escreva v(i)
fim para
{Determinar a sequncia de nmeros que produz a maior soma}
soma_maior v(0)
para i 0 at TAM_VEC faa
para j i at TAM_VEC faa
soma soma + v(j)
{operao mais relevante}
se soma > soma_maior ento
soma_maior <= soma
fim se
fim para
soma = 0;
fim para
escreva soma_maior

fim Refinamento algoritmo

Algoritmo final
TESTES DO ALGORITMO
Execuo dos testes:
bruno@Bruno-PC:$ nano ex_02.c // 20 elementos
bruno@Bruno-PC:$ gcc ex_02.c -o ex_02
bruno@Bruno-PC:$ ./ex_02
-81 -4 -75 -94 -87 -11 -86 -38 -14 -91 94
9 -34
2 68 -48
A maior soma sequencial no vetor : 354
bruno@Bruno-PC:$ nano ex_02.c // 26 elementos
bruno@Bruno-PC:$ gcc ex_02.c -o ex_02
bruno@Bruno-PC:$ ./ex_02
-26 15 -65 -30 -25
8 -41 -53 45 -53 86 42 -29
-17 88 -93 70 -79 66 -45 -84 -40
A maior soma sequencial no vetor : 191
bruno@Bruno-PC:$ nano ex_02.c // 32 elementos

50

89

23

53

25

67 -48 -82

bruno@Bruno-PC:$ gcc ex_02.c -o ex_02

bruno@Bruno-PC:$ ./ex_02
-34 44 -66 -25 67 -10 -27 -96 78 13
-51 -24 37 -16 -86 -11 -95 54 -59 -19
A maior soma sequencial no vetor : 152

-2 34 -98
18 -66 -94

74
42

53 -90 -68
-3

bruno@Bruno-PC:$ nano ex_02.c // 38 elementos

bruno@Bruno-PC:$ gcc ex_02.c -o ex_02
bruno@Bruno-PC:$ ./ex_02
51 -32
5 -32 59 -83 -42 -28 85 82 24 -72 87 -38 65 81 33
60 28 -9 -13 -78 -98 -99 14 -79 -80 90 -69 54 92 82 -76 -4 -49
82 13
6
A maior soma sequencial no vetor : 435
bruno@Bruno-PC:$ nano ex_02.c // 44 elementos
bruno@Bruno-PC:$ gcc ex_02.c -o ex_02
bruno@Bruno-PC:$ ./ex_02
-53
6 -16 -35 -90 21 95 -11 18 -49 64 -94 40
6
1
76 -4 -58 25 -52 82 -34 80 55 -37 -51 32 -99 -93 76
13 -92 -63 -97 25 -15 65 29 -73
A maior soma sequencial no vetor : 233

9 -37
4 -12 -57

bruno@Bruno-PC:$ nano ex_02.c // 50 elementos

bruno@Bruno-PC:$ gcc ex_02.c -o ex_02
bruno@Bruno-PC:$ ./ex_02
-87 -81 88 28 -67 -26 -16 22 73 42 -83
2 -83 69 55 -5 58
97
3 38 -20 32 34 -57 55
1 57 -59 -84 -87 -87 -72 -69 98 53
-39 -28 -61 81 -54 80 97 48 94 68
2 -11 27
0 91
A maior soma sequencial no vetor : 546

ANLISE DA COMPLEXIDADE
Denotemos por N o valor de TAM_VEC e elejamos como instruo mais importante a que
est na linha 18 do algoritmo final na pgina anterior: soma soma + v(j). A funo de custo do
algoritmo, f(n), dada por:
n

i=0

i=0

i=0

1 = 1(n i + 1) = n i + 1 = n(n 0 + 1)
i=0 j=i
2

i=0

n + n

n
n
n
3n
+n+1= +
+1
2
2
2
2

f (n) =

n(n+1)
+ 1(n 0 + 1)
2

n + 3 n + 2
2

Logo, podemos dizer que a funo O(n).

Demonstrao:
Pela definio da notao O, uma funo f(n) O(g(n)) se { n0 , c 0 f (n) cg(n) }.
Sendo f (n) =

n + 3 n + 2
e g(n) = n2 , temos:
2

n + 3n + 2
n2 3 n 2 2 cn2
3 2
2
0
cn 0 2 + 2 + 2 2 0 1 + + 2 2 c
2
n n
n
n
n
n
Para n0 = 1 e c = 3 , a relao acima se satisfaz n n 0 .

TESTES DE TEMPO DE EXECUO

A Tabela 02 relaciona os tempos de execuo do algoritmo em funo do nmero de elementos do vetor de inteiros.
Tabela 02: Tempos de execuo do algoritmo em relao ao tamanho do vetor
N (TAM_VEC)

1.000e+04

5.000e+04

1.000e+05

5.000e+05

Tempo (s)

2.900e-01

7.370e+00

2.947e+01

7.548e+02

O grfico a seguir confirma a predio de que o algoritmo O(n):

ANLISE DO EXPERIMENTO 2
Utilizando-se a tcnica dos refinamentos sucessivos projetou-se um algoritmo para resolver o
problema deste experimento. Esta tcnica mostra-se bastante eficaz na elaborao de algoritmos
grandes e complexos, uma vez que o desenvolvedor no precisa se preocupar com os detalhes de
uma linguagem programao especfica, concentrando-se somente na lgica do algoritmo.
Atravs de testes exaustivos com vetores com uma quantidade de elementos reduzida, constatou-se que o algoritmo implementado cumpre corretamente seu objetivo. Em seguida, utilizando
vetores de 20 50 elementos, o algoritmo tambm produziu a sada desejada.
Pela anlise de complexidade, obteve-se uma funo de ordem de complexidade O(n), o que
condiz com a natureza do algoritmo. Como a parte do algoritmo que lida com o processamento do
vetor a fim de determinar a maior soma consecutiva foi escrita com duas iteraes aninhadas, j era
de se esperar que este algoritmo apresentasse esta ordem de complexidade.
Analisando-se os tempos de execuo utilizando o mesmo procedimento adotado no experimento 1 (atravs do programa mede_tempo.c), observou-se que o tempo de execuo do algoritmo
proporcional ao quadrado do nmero de elementos do vetor. Por exemplo, se aumentarmos de
1.000 para 10.000 o nmero de elementos do vetor, o tempo de execuo ser 10 vezes maior.

CONCLUSO
Aps realizar este trabalho prtico, pode-se constatar que o tempo de execuo de um
algoritmo diretamente proporcional sua ordem de complexidade. Isto uma caracterstica
importante a ser levada em considerao se o algoritmo processa um nmero muito grande de
dados ou se ele executado muitas vezes. A complexidade de tempo de um algoritmo quantifica o
tempo tomado por um algoritmo para rodar em funo do tamanho da entrada do problema.
Um mesmo problema pode ser resolvido por diversos algoritmos. A escolha do algoritmo deve
estar condizente com aplicao do mesmo. Algoritmos com ordem de complexidade menores
devem ser elegidos para resolver problemas que tem uma entrada de dados maior.

ANEXO 01: Implementao do algoritmo do experimento 2 em linguagem C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

/* Autor: Bruno de Araujo Coutinho

* Data: 25/04/2014
* Objetivo: Dada um vetor aleatrio de TAM_VEC elementos,
determinar a sequncia de nmeros do vetor que gera a
maior soma possvel.
*---------------------------------------------------------*/
#include <stdio.h>
#include <time.h>
#define LIM_VEC 99
#define TAM_VEC 50
int main () {
int i, j, soma=0, soma_maior;
int v[TAM_VEC];
/* Preenche um vetor de TAM_VEC posies com
* nmeros entre -LIM_VEC e +LIM_VEC
*-------------------------------------------*/
srand (time (NULL));
for (i = 0; i < TAM_VEC; i++)
v[i] = -LIM_VEC + rand () % (2 * LIM_VEC);
/* Imprime o vetor gerado aleatoriamente
*-------------------------------------------*/
for (i = 0; i < TAM_VEC; i++)
printf ("%3d ", v[i]);
/* Determina a sequncia de nmeros do vetor
* que produz a maior soma
*-------------------------------------------*/
soma_maior = v[0];
for (i=0; i<TAM_VEC; i++) {
for (j=i; j<TAM_VEC; j++){
soma += v[j];
if (soma >= soma_maior)
soma_maior = soma;
}
soma=0;
}
printf("\nA maior soma sequencial no vetor : %i\n", soma_maior);