Universidade Católica de Moçambique

Faculdade de Ciências Sociais e política

Curso: Tecnologia de informação – Laboral

2° ano

Cadeira: Estrutura de Dados e Algoritmo

Tema: Analise de Complexidade e Vectores

Docente: Wilson Maia

Nome: Dario Francisco

Quelimane, Junho de 2021

Índice
Introdução......................................................................................................................1

1. Analise de complexidade........................................................................................2

1.1. Complexidade de algoritmos..............................................................................2

1.2. Tempo de execução............................................................................................2

1.3. Medidas de Complexidade..................................................................................2

1.4. Comparação entre Complexidades.....................................................................3

1.5. Complexidade espacial e temporal.....................................................................3

1.6. Análise assintótica..............................................................................................3

2. Vector.....................................................................................................................4

2.1. Características:....................................................................................................4

2.2. Escrita de Dados de um Vetor............................................................................5

Conclusão.......................................................................................................................7

Referencia bibliográfica.................................................................................................8
Introdução
Ao introduzir este presente trabalho de analise de complexidde, podemos por analisar a
eficiência de algoritmos faz pouco sentido medir os recursos gastos em computadores
específicos, porque devido a diferentes conjuntos de instruções, arquiteturas e
desempenho dos processadores, as medidas são difíceis de comparar. Portanto, usamos
um modelo de uma máquina que reflita as características de computadores comuns, mas
é independente de uma implementação concreta.

1
 1. Analise de complexidade

A análise de algoritmos (ou análise de complexidade) é um mecanismo para entender e

avaliar um algoritmo em relação aos critérios destacados, bem como saber aplica-los à
problemas práticos.

1.1. Complexidade de algoritmos

Algoritmos é sequência de instruções necessárias para a resolução de um problema bem

formulado, permite implementação computacional. Um algoritmo resolve o problema
quando para qualquer entrada produz uma resposta correcta, mesmo resolvendo um
problema, um algoritmo pode não ser aceitável na prática por requerer muito espaço e
tempo.

1.2. Tempo de execução

A eficiência de um algoritmo pode ser medida através de seu tempo de execução. O

tempo de execução não depende somente do algoritmo, mas do conjunto de instruções
do computador, a qualidade do compilador, e a habilidade do programador.

O tempo de execução de um algoritmo para uma determinada entrada pode ser medido
pelo número de operações primitivas que ele executa. Como esta medida fornece um
nível de detalhamento grande convém adoptar medidas de tempo assintótica.

1.3. Medidas de Complexidade

Complexidade é também chamada esforço requerido ou quantidade de trabalho.

 Complexidade no pior caso: Considera-se a instância que faz o algoritmo

funcionar mais lentamente;
 Complexidade média: Considera-se todas as possíveis instâncias e mede-se o
tempo médio.

A complexidade pode ser calculada através do:

 Tempo de execução do algoritmo determinado pelas instruções executadas:

quanto “tempo” é necessário para computar o resultado para uma instância do
problema de tamanho n;
 Espaço de memória utilizado pelo algoritmo: quanto “espaço de memória/disco”
é preciso para armazenar a(s) estrutura(s) utilizada(s) pelo algoritmo.

2
O esforço realizado por um algoritmo é calculado a partir da quantidade de vezes que a
operação fundamental é executada. Para um algoritmo de ordenação, uma operação
fundamental é a comparação entre elementos quando à ordem.

1.4. Comparação entre Complexidades

A complexidade exacta possui muitos detalhes

 A escolha de um algoritmo é feita através de sua taxa de crescimento

 Esta taxa é representada através de cotas que são funções mais simples.
 A ordem de crescimento do tempo de execução de um algoritmo fornece uma
caracterização simples de eficiência do algoritmo.

1.5. Complexidade espacial e temporal

 Complexidade espacial de um programa ou algoritmo

Espaço de memória que necessita para executar até ao fim. S(n): espaço de memória
exigido em função do tamanho n da entrada.
 Complexidade temporal de um programa ou algoritmo

Tempo que demora a executar (tempo de execução): T(n) : tempo de execução em

função do tamanho n da entrada

 algoritmo é implementado numa dada linguagem

 A linguagem é compilada e o programa é executado num dado computador
 Difícil prever tempos de execução de cada instrução e antever optimizações
 Muitos algoritmos são “sensíveis” aos dados de entrada
 Muitos algoritmos não são bem compreendidos

1.6. Análise assintótica

Análise assintótica deve-se preocupar com a eficiência de algoritmos quando o tamanho
de n for grande. A eficiência assintótica de um algoritmo descreve a eficiência relativa
dele quando n se torna grande. Portanto, para comparar 2 algoritmos, determinam-se as
taxas de crescimento de cada um: o algoritmo com menor taxa de crescimento rodará
mais rápido quando o tamanho do problema for grande.

3
 2. Vector

Vector é uma estrutura de dados muito utilizada. É importante notar que vectores são
caracterizadas por terem todos os elementos pertencentes ao mesmo tipo de dado. Este
tipo de dados é utilizado para armazenar uma lista de valores do mesmo tipo, ou seja,
permite armazenar mais de um valor na mesma variável.

Um dado vector é definido como tendo um número fixo de células idênticas (seu
conteúdo é dividido em posições). Cada célula armazena um e somente um dos valores
de dados do vector, cada célula do vector possui seu próprio endereço, ou índice,
através do qual pode ser referenciada.

Forma geral: tipo_da_variável nome_da_variável [tamanho];

2.1. Características:
 Alocação estática (no momento da declaração deve-se especificar o tamanho do
vector)
 Estrutura homogênea
 Alocação sequêncial (bytes contíguos)
 Inserção/Exclusão
 Realocação dos elementos
 Não libertação da memória alocada

figura: vector referente às notas de um aluno

Nota B:

 Endereço Elemento 1 endereço inicial

 Endereço Elemento 2 endereço inicial + tamanho Elemento
 Endereço Elemento 3 endereço inicial + (2 * tamanho Elemento)
 Endereço Elemento 2 endereço inicial + (3 * tamanho Elemento)

4
A partir do endereço do primeiro elemento é possível determinar a localização dos
demais elementos do vector, porque os elementos do vector estão dispostos na memória
um ao lado do outro e cada elemento tem o seu tamanho fixo. É possível deduzir a
fórmula genérica para o cálculo de posição na memória de um elemento qualquer.
Sendo n o elemento, a fórmula se dá por:

Posn = endereço inicial + ((n - 1) * tamanho do tipo do elemento).

2.2. Escrita de Dados de um Vetor

A escrita de um vetor obedece à mesma sintaxe da instrução primitiva de saída de dados

e também vale lembrar que, além do nome do vetor, deve-se também especificar por
meio do índice o componente a ser escrito.

escreva (<nome_do_vetor> [<índice>])

O algoritmo a seguir exemplifica a operação de leitura e escrita de um vetor, utilizando

a construção para:

algoritmo “escrita_vetor"
var vet:vetor [0..10] de inteiro
i: inteiro

inicio
para i de 0 ate 10 faca
escreva ("Entre com vetor[",i,"]: ")
leia (vet[i])
fimpara
para i de 0 ate 10 faca
escreva (vet[i])
fimpara
fimalgoritmo

Exemplo:
Fazer um algoritmo para ler 10 valores que devem ser armazenados em um vetor,
calcular e mostrar a soma e média desses valores.

5
Resolução
algoritmo “vetor_exemplo"
var vet:vetor [1..10] de real
i:inteiro
soma, media: real
inicio
para i de 1 ate 10 faca
escreva ("Entre com vetor[",i,"]: ")
leia (vet[i])
soma <- soma + vet[i]
fimpara
media<-soma/10
escreval (“Soma dos valores: “, soma)
escreval (“Média dos valores: “, media)
fimalgoritmo

6
Conclusão
Ao concluir este presente trabalho que aborda sobre complexidade e matriz. Pode ver
que determinar o tempo de execução de um algoritmo pode ser complexo. Determinar a
complexidade assintótica, sem preocupação com as constantes envolvidas, pode ser uma
tarefa mais simples. Análise de algoritmos utiliza técnicas de matemática discreta.

7
Referencia bibliográfica
1) Carvalho, M. A. G. Tópicos Especias de Informática, 2004. Campinas, Brasil.
2) ROCHA, A. Estrutura de dados e algoritmos em C, FCA Lisboa 2008
3) http://www.inf.puc-rio.br
4) http://homepages.dcc.ufmg.br
5) http://www.caelum.com.br
6) http://www.ft.unicamp.br/~magic/analisealgo/apoalgoritmos_ceset_magic.pd
7) www.flf.edu.br/revista-flf.edu/volume08/Vol8_Artigo1.pdf