Vous êtes sur la page 1sur 6

Mtodos de Ordenao de Vetores

Ordenao pelo Mtodo Bolha


> O Mtodo Bolha, tambm chamado de Bubble Sort, um mtodo de ordenao de vetores por seleo e troca. um dos mtodos mais simples, mas, dentre todos os mtodos simples, o mais eficaz. adequado apenas para arquivos pequenos. Esse mtodo funciona da seguinte forma: esse mtodo ir percorrer o vetor vrias vezes e, durante a anlise, ele ir comparar os valores dois a dois e, caso estejam fora da ordem, esse algoritmo trocar a posio desses valores, deixando estes ordenados, ou seja, deixando-os em ordem crescente. Isso ir se repetir com todas as posies do vetor at a ltima posio, garantindo que o elemento de maior valor seja levado para a ltima posio. Vale ressaltar que o tempo de consumo do Bubble Sort proporcional ao nmero de execues da comparao sendo que, no melhor caso, o algoritmo executa n/2 operaes relevantes, onde n representa o nmero de elementos do vetor e, no pior caso, so feitas 2n operaes no vetor. Se o vetor a ser ordenado for colocado na vertical, com o Item[n] em cima e Item[1] embaixo, durante cada passo o menor elemento sobe at encontrar um elemento maior ainda, como se uma bolha subisse dentro de um tudo de acordo com sua densidade e, por isso, esse mtodo recebe o nome de bolha.

Exemplo:

#include int main(void) { int i, j,v[100], n, temp; for (i = n - 1; i > 0; i--) for (j = 0; j < i; j++) if (v[j] > v[j+1]) { temp = v[j]; v[j] = v[j+1; v[j+1 = temp; } return 0; }

Mtodo da Bolha Melhorado

O Mtodo da Bolha Melhorado o prprio mtodo bolha, mas com algumas alteraes. Esse mtodo finalizado quando nenhuma alterao foi feita aps uma passada no vetor, diminuindo o tempo de consumo do algoritmo.

Exemplo:

#include int main(void) { int i, j, v[100], n, temp, troca; troca = 1; for (i= n-1; (i >= 1) && (troca == 1); i--) { troca = 0; for (j= 0; j < i ;j++) { if (v[j] < v[j+1]) { temp = v[j]; v[j] = v[j+1]; v[j+1] = temp; troca = 1; } } } return 0; }

Ordenao pelo Mtodo Quicksort


O Mtodo Quicksort o algoritmo de ordenao interna mais rpido que se conhece para uma ampla variedade de situaes, sendo provavelmente mais utilizado do que qualquer outro algoritmo. O algoritmo foi inventado por C. A. R. Hoare na dcada de 1960, quando visitava a Universidade de Moscou como estudante. Esse algoritmo foi publicado em 1962, depois de uma srie de refinamentos.

A ideia bsica do Quicksort partir o problema de ordenar um conjunto com n itens em dois problemas menores. Depois de dividir o problema, os problemas menores so ordenados independentemente e depois os resultados so combinados para produzir a soluo do problema maior. A parte mais delicada desse mtodo se refere diviso da partio. Deve-se rearranjar o vetor na forma A[Esq..Dir] atravs da escolha arbitrria de um item x do vetor chamado piv, de tal forma que ao final o vetor A est particionado em uma parte esquerda com chaves menores ou iguais a x e uma parte direita com chaves maiores ou iguais a x. O Procedimento do Algoritmo Quicksort se d da seguinte forma: 1. Escolher arbitrariamente um item do vetor e colocar este valor em x; 2. Percorrer o vetor a partir da esquerda at que um item A[i] x encontrado; da mesma maneira, percorrer o vetor a partir da direita at que um item A[j] x encontrado; 3. Como os itens A[i] e A[j] no esto na ordem correta no vetor final, eles devem ser trocados; 4. Continuar o processo at que os ndices i e j se cruzem em algum ponto do vetor.

Ao final do processo, o vetor A[Esq..Dir] est particionado de tal forma que:

>> Os itens em A[Esq], A[Esq+1], ... , A[j] so menores ou iguais a x. >> Os itens A[i], A[i+1], ... , A[Dir] so maiores o iguais a x.

O mtodo ilustrado para o conjunto de seis chaves apresentado na figura abaixo. O item x escolhido como sendo A[(i+j)div2]. Como inicialmente i = 1 e j = 6, ento x = A[3] = D, o qual aparece em destaque na segunda linha da mesma figura. A varredura a partir da posio 1 pra no item O e a varredura a partir da posio 6 pra no item A, sendo os dois itens trocados, como mostrado na terceira linha da figura. A seguir, a varredura a partir da posio 2 pra no item R e a varredura a partir da posio 5 pra no item D, e ento os dois itens so trocados, como mostrado na quarta linha. Neste momento i e j se cruzam (i = 3 e j = 2), o que encerra o processo de partio. 1 2 3 4 5 6

i=1 i=2 i=3

O A A

R R D

D D R

E E E

N N N

A O O

Feito este procedimento, o algoritmo agora ter de fazer a ordenao, ou seja, o refinamento final do procedimento Quicksort. Veja o exemplo de ordenao usando o Quicksort:

Chaves iniciais

i=1 i=2 i=3 i=4 i=5 i=6

A A

D D

R N

N R O

O O R R

Algoritmo do Procedimento Partio:

procedure Particao (Esq, Dir: ndice; var i, j : ndice); var piv, x: Item; begin i := Esq; j := Dir; piv := A[(i+j) div 2)]; repeat; while piv.Chave > A[i].Chave do i := i+1; while piv.Chave < A[j].Chave do j :=j-1; if i <= j then begin x := A[i]; A[i] := A[j]; A[j] :=x; i := i+1; j :=j-1; end; until i>j; end; Analisando a procedure:

>> Esq e Dir so ndices para definir os sub-vetores do vetor original A a ser particionado

>> i e j retornam as posies finais das parties, onde: > A[Esq], A[Esq+1],..., A[j] so menores ou iguais a x

> A[i], A[i+1],..., A[Dir] so maiores ou iguais a x

>> O vetor uma varivel global ao procedimento Partio

Procedimento Quicksort:

procedure Quicksort (var A: Vetor); {-- Entra aqui o procedimento partio --} procedure Ordena (Esq, Dir : ndice); var i, j, ndice; begin partio (Esq, Dir, i, j); if Esq < j then Ordena (Esq, j); if i < Dir then Ordena (i, Dir); end; begin Ordena (1, n); end;

Uma caracterstica interessante do Quicksort a sua ineficincia para arquivos j ordenados quando a escolha do piv e inadequada. Por exemplo, a escolha sistemtica dos extremos de um arquivo j ordenado leva ao seu pior caso. O pior caso pode ser evitado atravs de pequenas modificaes no programa.

Ordenao pelo Mtodo Selection Sort


O algoritmo de ordenao por seleo (selection sort) um dos mtodos de ordenao mais simples que existem. Alm disso, o mtodo possui um comportamento espetacular quanto ao nmero de movimentos de registros, cujo tempo de execuo linear no tamanho da entrada, o que muito difcil de ser batido por qualquer outro mtodo. Consequentemente, este o algoritmo a ser utilizado para arquivos com registros muito grandes. Este mtodo possui alguns aspectos negativos, so eles: o fato do arquivo j estar ordenado no ajudar em nada, pois o custo continua quadrtico; o algoritmo no estvel, pois ele nem sempre deixa os registros com chaves iguais na mesma posio relativa. Este mtodo funciona da seguinte forma: selecione o menor item do vetor e a seguir troque-o com o item que est na primeira posio do vetor. Repita estas duas operaes com os n-1 itens restantes, depois com os n-2 itens, at que reste apenas um elemento. Ou seja, o mtodo passar sempre o menor valor do vetor para a primeira posio (ou o maior dependendo da ordem requerida), depois o de segundo menor valor para a segunda posio e assim por diante. Exemplo de algoritmo:

procedure Seleo (var A: Vetor); var i, j, Min : ndice; x begin for i := 1 to n-1 do begin Min i := i; for j := i+1 to n do if A [j].Chave < A[Min].Chave then Min := j; x := A[Min]; A[Min] := A[i]; A[i] := x; end; end; : Item;