Você está na página 1de 7

FACULDADE ANHANGUERA DE TAUBAT

UNIDADE II

Anlise e Complexidade de Algoritmos
Prof. Giselle Pires


Atividade Prtica Supervisionada
Curso: Cincia da Computao
Ano: 2014

Nome: Ana Paula De Castro Gil
Ra:3705616388




Etapa 1

Melhor Caso

* Definido pela letra grega (mega).
* Exprime o menor tempo de execuo de um algoritmo para uma entrada de tamanho
n.
* Ex: f(n)=(1)

Pior Caso

* Representado pela letra grega 0 (micron).
* Baseia-se no maio tempo de execuo sobre todas as entradas de tamanho n.
* o mtodo mas fcil de se obter.
* Ex: f(n)=0(1)

Caso Mdio
* Definida pela letra grega (Theta)
* Deve- se obter a mdia dos tempos de execuo de todas as entradas de tamanho
n, ou baseado em probabilidade de determinada condio ocorrer.
* Ex: f(n)=(n/2)

Comparar uma funo Linear f(n) com uma funo Quadrtica g(n).
* Funo Linear f(n) = 5n +2
* Funo Quadrtica g(n) = 2n

f(n)= 5n+2
g(n)=2n
f(n) o(g(n))?

Para n 3 o(g(n)).

Comparar uma funo exponencial f(n) com uma funo cbica g(n).
* Funo exponencial f(n) = 2n n
* Funo cbica g(n) = n+2n

f(n)=2n n
g(n)= n+2n
f(n)(g(n))?

Para n 5 (g(n).

Comparar duas funes quadrticas f(n) e g(n).
* Funo quadrtica f(n) = n+4+3n
* Funo quadrtica g(n) = 5n+3

o c1 f(n) g(n) o
g(n) c2 f(n)



Crie um Algoritmo.

Procedure Verifica_Item_Lista
(Lista: TipoLista; x: TipoItem; pos: integer);
Var i: integer;
Begin
I: = 1;
achou := false;
While (i <= Lista.Tamanho) and not achou do begin
inc(i);
if Lista.Intem[i] = then
achou := true;
end;
if achou then
pos := i
else
pos := -1;

Etapa 2

Cite as vantagens e desvantagens dos algoritmos de ordenao por seleo e de
ordenao por insero.

* Ordenao por Seleo (SECTION SORT)

um algoritmo que ordena itens verificando repetidamente os itens restantes para
encontrar o menor deles e mov-lo para uma posio final. A idia por trs do
selection sort que para ordenar N itens voc tem que passar por todos eles.
1. No primeiro passo voc encontra o maior valor, e ento troca ele pelo ltimo item.
Assim o maior item est agora na posio N.
2. No segundo passo voc faz uma varredura apenas nos N-1 elementos. O maior dos
itens troca de posio com o item na posio N-1. Assim o maior de todos os itens
est agora na ltima posio; O segundo maior na segunda maior posio.
3. Este processo repetido, com um item sendo colocado na sua posio correta a
cada vez.
4. Depois de N passos, a coleo inteira de dados est ordenada. Uma variao
simples encontrar o menor item a cada vez e coloc-lo2na frente. Para ordenar em
ordem decrescente, o maior item encontrado a cada vez e movido para a frente.

Pior e melhor caso: O(n2)

* Ordenao por Insero (INSERTION SORT)

um algoritmo eficiente para ordenar um pequeno nmero de elementos.
Basicamente, este algoritmo varre um array de elementos da esquerda para a direita e
a medida que avana vai deixando os elementos mais a esquerda ordenados.

Melhor caso: quando o array j est ordenado. Neste caso a comparao no lao
interno sempre falhar na primeira comparao e o tempo de execuo depender
apenas do lao externo. O tempo de execuo obedecer a uma funo linear e a
complexidade do algoritmo ser de O(n).
Pior caso: quando o array est na ordem inversa. Nesta situao para cada iterao
do lao externo, o lao interno executar n-1 vezes, onde n o valor da varivel j no
lao externo. Temos que a complexidade de tempo do algoritmo neste caso ser de
O(n(n-1)) = O(n2-n) = O(n2).

Crie um algoritmo de ordenao por insero e um de ordenao por seleo.

* Ordenao por Insero (Insertion Sort)

1 void insertion(int v[], int n) {
2 int i, j, x;
3 for(j=1;j<n;j++) { o(n)
4 x = v[j]; o(1)
5 for(i=j-1;i >=0 && v[i]>x;--i)
o(n)
6 v[i+1] = v[i]; o(1)
7 v[i+1] = x; o(1)
8 }
9 }

=o(n)+o(1)+o(n)+o(1)+o(1)
=o(n)+o(n)+o(1)+o(1)+o(1)+o(1)
=o(n2)+0(3)
=n2+3

n2+3 uma funo quadrtica.

* Ordenao por Seleo (Selection Sort)

1 void selectionSort(int vetor[],int tam ){
2 int i,j;
3 int min,aux; o(1)
4 for (i=0;i<tam-1;i++){ o(tam)
5 min=i; o(0)
6 for (j=i+1;j<tam;j++){ o(tam)
7 if (vetor[j]<vetor[min]) o(1)
8 min=j; } o(0)
9 aux=vetor[i]; o(1)
10 vetor[i]=vetor[min]; o(1)
11 vetor[min]=aux; o(1)
12 }
13 }

=o(1)+o(tam)+o(tam)+o(1)+o(o)+o(1)+o(1)+o(1)
=o(1)+o(1)+o(1)+o(1)+o(1)+o(tam)+o(tam)
=5o(1)+o(tam)
=5 +tam2

5+tam uma funo quadrtica.