Você está na página 1de 2

Ordenao: problema recorrente na computao.

Metodos elementares: metodos simples e faceis de implementar, porm compartilham a


caracterstica de ter o tempo
de execuo no pior caso limitado ser limitado superiormente por uma funo do segundo g
rau.
############################################################################
BubbleSort: consiste em percorrer o vetor vrias vezes, no qual em cada passagem c
oloca um elemento na sua posio, da forma que
o maior elemento na maior posio posio, o segundo maior elemento na segunda maior pos
io, o n-simo maior elemento na n-sima
maior posio e os demais elementos vo se aproximando de suas posies.
um algoritmo de ordenao estvel, ou seja, no alterar a ordem relativa entre elementos
de mesma chave. Ou seja, se em uma sequencia qualquer
h dois elementos de chaves repetidas, digamos A1 e A2, no qual na sequencia de en
trada A2 vem antes de A1, na sequencia de saida(ordenada) A2
tambm vira antes de A1;
Implementao mais simples, sem realizar nenhuma optimizao:
para i <- 1 ate n faa
para j <- 1 ate n-1 faa
se v[j] > v[j+1] ento
troca(v[j], v[j+1]);

Essa implementao muito simples, porem possvel realizar algumas otimizaes no algoritm
, verifica se voc consegue
Primeira otimizao: Para orndenar n elementos de uma sequncia basta orndear n-1 elem
entos que o elemento restante automaticamente
se arranjara em sua posio. Dessa forma:
para i <- 1 at (((n - 1))) faa
para j <- 1 at n-1 faa
se v[j] > v[j+1] ento
troca(v[j], v[j+1]);
Segunda otimizao: A cada passagem do loop externo um elemento posto em sua posio, de
ssa forma na primeira passagem o maior elemento
ser colocado na primeira maior posio, na segunda passagem o segundo maior elemento
na segunda maior posio, n-sima passgem o n-simo
maior elemento na n-sima maior posio. Sendo assim o loop interno no precisa a todo p
assagem externa percorrer a sequncia toda novamente.
Sendo assim, temos a segunda otimizao:
para i <- 1 at n - 1 faa
para j <- 1
at (((n-1-i))) faa
se v[j] > v[j+1]
troca(&v[j], &v[j+1]);

Essas otimizaes so to simples que parece at no surgir efeito na prtica, mas em sistema
no qual o tempo essencial tais otimizaes se
mostram relevantes.
Terceira otimizao: Mesmo com a sequncia ordenada o BubbleSort ainda contiua a perco
rrer o vetor sem realizar nenhuma troca, uma vez que os elementos
j se encontram em suas posies. Dessa forma, no faz sentido continuar a execuo do algor
itmo, e assim chegamos a nossa terceira otimizao:

swaped = 1
para i <- 1 at n - 1 e swaped faa
swaped = 0;
para j <- 1 at n-1-i faa
se v[j] > v[j+1]
troca(&v[j], &v[j+1])
swaped = 1
Quarta otimizao: pode-se reduzir ainda mais o numero de passo do algoritmo. Tornad
o para isso a a segunda otimizao um pouco melhor.
swaped = 1
bound = n-1
para i <- 1 at n - 1 e swaped faa
swaped = 0
para j <- 1 at bound faa
se v[j] > v[j+1]
troca(&v[j], &v[j+1])
swaped = 1
newbound = j
bound = newbound

Discusso: Nem todas essas otimizaes so genricas, ou seja, no sutem efeitos aplicadas a
qualquer sequencia. Apenas a primeira e a segunda so.
A terceira s surte efeito quando aplicada a uma sequncia quase ordenada, se aplica
da a uma sequencia em ordem descrecente no resultara em nada.
Se aplicada a uma sequencia quase ordenada ai sim tem-se um grau de otimizaao. A
mesma coisa ocorre com a quarta.
################################################################################
############
SelectionSort: consiste em percorrer o vetor vrias vezes, no qual em cada passage
m pega-se o n-simo menor elemento e coloca
na n-sima menor posio
para i <- 1 at n - 1 faa
min <- i;
para j <- i+1 at n faa
se v[j] < v[min] ento
min = j;
troca(&v[i], &v[min]);
InserctionSort