You are on page 1of 5

INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DE PERNAMBUCO

CAMPUS BELO JARDIM

ANNE INGRID F. BEZERRA

TÉCNICO INFORMÁTICA

2º C

MÉTODOS DE ORDENAÇÃO

Belo Jardim - PE

05-05-2009
Métodos de Ordenação

Ordenação consiste ao método de reorganizar um conjunto de objetos em


ordem crescente ou decrescente comparando os elementos para determinar
qual deles vem em primeira ordem na lista ordenada, tendo como objetivo
facilitar a recuperação de itens de um determinado conjunto.

Existem muitos algoritmos de ordenação, a escolha mais eficiente vai


depender de vários fatores, tais como: número de itens a ser classificado; se os
valores já estão agrupados em subconjuntos ordenados etc.

Atualmente há uma grande necessidade de guardar informações e possuí-


las ordenadas, seja por ordem alfabética, por idade, localidade entre outros.

Os principais Métodos de ordenação são:

•Método de ordenação por selecção (Selecção Directa)

• Método de ordenação por inserção (com Pivot)

• Método de ordenação por bolha (Bubble Sort)

• Método de torneio (Quick Sort)

Métodos de ordenação Bolha (“Bubble Sort”)

Por ser simples e fácil de entender e implementar, o Bubble Sort está entre os
mais conhecidos algoritmos de ordenação. Porém, devido a sua baixa
eficiência, devemos tratá-lo como uma solução mais para desenvolvimento de
raciocínio que de uso recorrente (embora não seja um problema usá-lo em
casos onde não exige muita performance, como quando desejamos ordenar
um conjunto com poucos elementos).

Seu princípio é a comparação e troca de valores entre posições consecutivas,


fazendo com que os valores mais altos ( ou mais baixos) migrem (“borbulhem”)
para o final do vetor a ser ordenado.

Ex:

int aux;
for ( i=0; i <= tam-2; i++ )
for ( j=0; j<= tam-2-i; j++ )
if ( Array[j] > Array[j+1] )
aux = Array[j];

Array[j] = Array[j+1];
Array[j+1] = aux
Selecção

O método de ordenação por Selecção Directa é levemente mais eficiente


que o método Bubblesort, ainda que se trate de um algoritmo apenas para
estudo e ordenação de pequenas listas. A lógica consiste em se varrer a lista
comparando todos os seus elementos com o primeiro. Caso o primeiro
elemento esteja desordenado em relação ao elemento que está sendo
comparado com ele no momento, é feita a troca. Ao se chegar ao final da lista,
teremos o menor valor ( ou o maior, conforme a comparação ) na primeira
posição do arranjo.

Int aux;
for( i=0; i <= tam - 2; i++ ) {
for( j=i+1; j <= tam - 1; j++ ) {
if ( Array[j] < Array[i] ) {
aux = Array[j];
Array[j] = Array[i];
Array[i] = aux;

Comparações de tempo:

Existe um ciclo que é executado n vezes, mas o tempo não é de ordem n,


pois é necessária a informação do menor elemento e isto produz outro ciclo,
logo o algoritmo é de ordem N^2.

Inserção

Este método é o mais rápido entre os outros métodos considerados básicos.


O algoritmo, consiste em ordenar uma lista utilizando uma sub-lista ordenada
localizada em seu inicio, e a cada novo passo, acrescentamos a esta sub-lista
mais um elemento, até que atingimos o último elemento da lista fazendo assim
com que ela se torne ordenada. Funciona como se ordenássemos um baralho
que temos na mão direita, para a mão esquerda, passando uma carta de cada
vez.

long int aux;


long int j;
for( long int i=1; i <= tam - 1; i++ ) {
aux = Array[i];
j = i - 1;
while ( j >= 0 && aux < Array[j] ) {
Array[j + 1] = Array[j] ;
j--;
}
Array[j+1] = aux;

Métodos mais eficientes


Merge sort

Este método baseia-se na estratégia do dividir para conquistar! A sua ideia


é dividir o vector em duas partes iguais, até que resultem dois vectores com
apenas um único elemento.

void merge(int M[50], int p, int r) {


int q;
if (p<r) {
q=((p+r)/2);
merge(M,p,q);
merge(M,q+1,r);
intercala(M,p,q,r);
}
}

void intercala(int M[50], int p, int q, int r) {


int prim, res, seg, k;
int C[50];
prim = res = p;
seg = q+1;
while(prim<=q && seg<=r) {
if(M[prim]<=M[seg]) {
C[res] = M[prim];
prim++;
} else {
C[res] = M[seg];
seg++;
}
res++;
}
if(prim>q)
for(k=seg; k<=r; k++) {
C[res] = M[k];
res++;
} else {
for(k=prim; k<=q; k++) {
C[res] = M[k];
res++;
}
}
for(k=p; k<=r; k++)
M[k] = C[k];

Que tempos de ordenação podemos esperar?

O algoritmo requer 2n passos, um para copiar a lista para a sequência


intermediária e outra para a reordenar. Logo é de O(2nlog(n)) = O(n log n).

Quicksort
O quicksort é um dos algoritmos de ordenação mais simples e eficientes que
existem. O seu principio é muito semelhante ao mergesort.

Primeiro a lista a ordenar é partida em duas partes, de maneira a que os


elementos primeira parte sejam menores ou iguais a todos os elementos da
segunda. Recursivamente, as duas partes são ordenadas pelo mesmo
algoritmo e são então combinadas para dar a lista final. O primeiro passo é
escolher um elemento x e depois dividir. A ideia usada neste algoritmo também
é a dividir para conquistar

void quick(int Q[50], int inicio, int fim) {


int meio;
if (inicio<fim) {
meio = particiona(Q, inicio, fim);
quick(Q, inicio, meio-1);
quick(Q, meio+1, fim);
}
}
int particiona(int Q[50], int inicio, int fim) {
int pivo,ultbaixo,temp,i;
pivo = Q[inicio];
ultbaixo = inicio;
for(i=inicio+1; i<=fim; i++) {
if (Q[i]<=pivo) {
ultbaixo++;
temp = Q[i];
Q[i] = Q[ultbaixo];
Q[ultbaixo] = temp;
}
}
temp = Q[inicio];
Q[inicio] = Q[ultbaixo];
Q[ultbaixo] = temp;
return(ultbaixo);
}

No melhor caso, quando a partição da lista produz duas listas de igual


tamanho, o algoritmo tem O(N*logN). No Pior caso, quando a divisão faz com
que todos os elementos se posicionem de um lado, o algoritmo tem O(n^2).