Algoritmos de Ordenação Em Java

7/23/2019 Algoritmos de Ordenação Em Java

http://slidepdf.com/reader/full/algoritmos-de-ordenacao-em-java 1/13

oritmos de Ordenação em Java

://www.devmedia.com.br/algoritmos-de-ordenacao-em-java/32693[30/06/2015 11:33:59]

Gostei (3)

(0)

comentários favorito (3) marcar como lido para impressão anotar

Algoritmos de Ordenação em Java

Veja neste artigo como funcionam os algoritmos de ordenação InsertionSort, SelectionSort e QuickSort.

Neste artigo veremos como aplicar algoritmos de ordenação em Java, dada a sua devida necessidade em ocasiões

específicas. Existem diversas aplicabilidades para a ordernação de dados, não só em Java, mas no mundo computacional

como um todo.

A ideia de conhecer diversos algoritmos para ordenar dados é saber qual utilizar para conseguir um melhor desempenho ou

uma melhor legibilidade de código, dependendo da necessidade. Não precisamos usar, por exemplo, um algoritmo

“supercomplexo“ para ordenar 10 valores em um vetor, certo? Seria desperdício de tempo desenvolver um algoritmo tão

complexo para resolver um problema tão simples.

Para analisar um algoritmo de ordenação você deve conhecer a sua complexidade no Pior Caso, Caso Médio e o melhor

caso. Estas três características presentes em todos os algoritmos dizem respeito a sua velocidade dada uma situação

específica. Atente-se a esses conceitos, pois falaremos deles posteriormente, citando a complexidade do algoritmo através de notação matemática.

09

INICIAR ASSINE MVP

Buscar

http://www.devmedia.com.br/favorite/addfavorite.asp?comp=32693

http://www.devmedia.com.br/favorite/add_finished.asp?comp=32693

http://www.devmedia.com.br/articles/viewcomp_forprint.asp?comp=32693

http://www.devmedia.com.br/anotacoes/add/?idcomp=32693

http://www.devmedia.com.br/mvp/


http://www.devmedia.com.br/anotacoes/add/?idcomp=32693

http://www.devmedia.com.br/articles/viewcomp_forprint.asp?comp=32693

http://www.devmedia.com.br/favorite/add_finished.asp?comp=32693

http://www.devmedia.com.br/favorite/addfavorite.asp?comp=32693

http://www.devmedia.com.br/





Algoritmos de Ordenação

InsertionSort

Sua teoria baseia-se em ordenar os valores da esquerda para a direita, deixando os elementos lidos (a esquerda)

ordenados. Este é geralmente utilizado para ordenar um pequeno número de valores, onde faz-se muito eficiente. A

complexidade do código é:

Complexidade Pior Caso: O(n²)

Complexidade Caso Médio: O(n²)

Complexidade Melhor Caso: O(n)

Quando temos um caso onde a complexidade é n² devemos evitar, visto que a redução de desempenho deste algoritmo é

exponencial. Porém, no seu melhor caso temos uma constante n que significa a inalteração da velocidade, proporcional à

quantidade de elementos.

Lembre-se que estamos trabalhando com proporcionalidade, então dizer que não varia não significa que um vetor de 10

elementos será ordenado na mesma velocidade de um vetor de um milhão de elementos, mesmo no melhor caso, porém a

proporcionalidade entre a quantidade de elementos e sua velocidade continua constante, diferente do Pior Caso que

aumenta ao quadrado.

O melhor caso ocorre quando todos os elementos já estão ordenados e o pior caso é exatamente o contrário, quando todos os elementos estão desordenados. Vejamos um exemplo para entender melhor essa teoria na Listagem 1.

Listagem 1. Aplicando InsertionSort

publ i c stat i c voi d mai n( St r i ng[ ] ar gs) t hr ows I OExcept i on {

i nt quanti dade = 10000;

i nt [ ] vet or = new i nt [ quant i dade] ;

f or ( i nt i = 0; i < vetor . l ength; i ++) { vet or [ i ] = ( i nt ) ( Mat h. r andom( ) *quant i dade) ;

}

l ong t empoI ni ci al = System. cur rent Ti meMi l l i s( ) ;

i nsert i onSort ( vet or) ;

l ong t empoFi nal = Syst em. cur r ent Ti meMi l l i s( ) ;

System. out . pr i nt l n( "Execut ado em = " + ( t empoFi nal - t empoI ni ci al ) + " ms") ;

}

publ i c stat i c voi d i nsert i onSort ( i nt [] vetor) {

i nt j ;

i nt key;





i nt i ;

f or ( j = 1; j < vetor . l ength; j ++)

{

key = vet or[ j ] ;

f or ( i = j - 1; ( i >= 0) && (vetor [ i ] > key) ; i - - )

{

vetor [ i + 1] = vetor [ i ] ;

} vetor [ i + 1] = key;

}

}

O primeiro passo é entender o funcionamento do método insertionSort(). Este irá percorrer todo o vetor começando do

segundo elemento e atribuindo o mesmo a uma variável chamada key.

O algoritmo começa fazendo uma iteração em todos os elementos do vetor, a partir do segundo elemento, por isso “j=1” e

não “j=0”.

A variável “key” armazena inicialmente o primeiro valor lido pelo laço for, que no caso será o segundo elemento do vetor. O

segundo laço itera sobre os valores que estão antes da variável “key”:

key = vetor[ j ] ;

f or ( i = j - 1; ( i >= 0) && (vetor [ i ] > key) ; i - - )

Perceba que a iteração mostrada continuará até que o valor de i seja maior ou igual a zero e o valor do vetor na posição i

seja maior que o valor de key.

Suponha o seguinte vetor: 30,20,10,40. Na primeira iteração o valor de key será 20, já que começamos a iteração a partir do

segundo valor. Na primeira iteração do segundo laço for o valor de i será igual a 0, porque o j será igual a 1, sendo assim o

i é >= 0 e o vetor[0] é maior que 20, pois vetor[0] = 30. Ao acessar o segundo laço for é feita uma atribuição.

Temos então que vetor[0+1] = vetor[0], ou seja, o valor 20 recebe o valor 30, ficando assim: 30,30,10,40. Quando ele tentar passar pela segunda vez no segundo laço for não será possível, pois i será -1.

Ao sair do segundo laço for o valor de vetor[i+1] recebe o que tínhamos armazenado em key.

No caso, vetor[-1 + 1] = 20, então temos 20, 30, 10, 40.

O mesmo prossegue até que todos os valores do vetor sejam percorridos e estejam ordenados.

A variável “i” serve para comparar sempre o elemento atual com o elemento anterior, pois ele faz com que seja possível

percorrer todos os elementos anteriores ao atual até achar algum que seja maior que o atual, fazendo com que este seja

substituído. Conforme a iteração for avançando os elementos a esquerda vão ficando ordenados.





Vejamos agora o que foi feito dentro do método main(), que será usado durante todo o desenvolvimento deste artigo.

O método main() possui uma iteração para preencher elementos de forma randômica:

f or ( i nt i = 0; i < vetor . l ength ; i ++) {

vet or [ i ] = ( i nt ) ( Mat h. r andom( ) *quant i dade) ;

}

Após o preenchimento destes elementos é chamado o método insertionsort(), que irá ordenar os valores, sendo que antes e

depois são gravadas variáveis do System.currentTimeMillis() para saber-se qual tempo de execução do algoritmo em

milissegundos.

O código da Listagem 1 representa o caso médio, onde alguns valores podem já estar ordenados e outros não, visto que

usamos o Math.random() e não saberemos qual vetor será construído. Para testar o melhor caso você deve trocar a linha

mencionada por:

f or ( i nt i = 0; i < vetor . l ength; i ++) {

/ / vet or[ i ] = ( i nt ) ( Mat h. random( ) *quant i dade) ;

vet or [ i ] = i + 1;

}

Vejamos na Tabela 1 os tempos médios: como o pior caso e o caso médio possuem a mesma complexidade decidimos

fazer a análise de apenas um destes.

InsertionSort

Elementos Caso médio (n²) Melhor Caso (n)

100 0 ms 0 ms

1.000 11 ms 0 ms

10.000 220 ms 1 ms

100.000 5110 ms 6 ms

200.000 20.272 ms 8 ms

Tabela 1. Medição de Tempo para InsertionSort

O que podemos perceber na tabela é que no caso médio temos uma alteração exponencial, aumentando muito o tempo

conforme o aumento do número de elementos. Ao analisar os tempos você verá um aumento considerável quando

trabalhamos com n². Por outro lado, no melhor caso o tempo mantem-se quase constante, enquanto temos 20.272 ms para

200.000 no caso Médio, temos 8 ms para a mesma quantidade no melhor Caso.





BubbleSort

O BubbleSort é conhecido pela sua simplicidade e pela eficácia ao realizar ordenações em um número limitado de valores.

Seu princípio baseia-se na troca de valores entre posições consecutivas, fazendo com que valores altos ou baixos

(dependendo da forma de ordenação desejada) “borbulhem” para o final da fila, por isso este algoritmo é chamado de

BubbleSort. Sua complexidade é:


Complexidade Caso Médio: O(n²)

Complexidade Melhor Caso: O(n)

Vimos que no melhor caso o seu tempo é quase inalterável, permanecendo constante, ou seja, um caso ideal.

Vejamos a implementação do bubbleSort na Listagem 2.

Listagem 2. BubbleSort





vet or [ i ] = ( i nt ) ( Mat h. r andom( ) *quant i dade) ; }


bubbl eSort ( vet or ) ;



}

pri vat e stati c voi d bubbl eSort ( i nt vet or[ ] ) {

bool ean t r oca = t r ue;

i nt aux;

whi l e ( t roca) {

tr oca = f al se;

f or ( i nt i = 0; i < vetor . l ength - 1; i ++) {

i f ( vet or [ i ] > vet or [ i + 1] ) {

aux = vetor[ i ] ;

vetor [ i ] = vetor [ i + 1] ;

vet or[ i + 1] = aux;

tr oca = tr ue;

}

}

}

}





Veja que o primeiro passo é criar as variáveis que nos auxiliarão na ordenação dos valores. Um laço while() é criado e

executado enquanto o valor de troca for true, e logo na primeira iteração já configuramos essa variável como false (você

entenderá mais à frente o porquê).

O laço for percorre o primeiro elemento até o último elemento -1 (ele nunca chegará a ler o último elemento) verificando se o

elemento atual que está sendo lido é maior que o próximo elemento que será lido.

Suponhamos então o seguinte vetor: 20, 10, 30.

A primeira iteração no laço for irá capturar o valor 20 e comparar com o próximo, que será 10. Então se 20 > 10, ele entrará

na condição fazendo a substituição destes valores:

i f ( vet or [ i ] > vet or [ i + 1] ) {

aux = vetor[ i ] ;

vetor [ i ] = vetor [ i + 1] ;

vet or[ i + 1] = aux;

tr oca = tr ue;

}

O valor 20, que está na posição i é armazenado na variável aux para não perdemos sua referência, depois o valor 10 que

está na posição i+1 é armazenado no local do valor 20. Trocamos agora o valor de i+1 pelo valor que armazenamos em

aux, que no caso é 20. A variável troca que antes era false, agora recebe true para indicar que houve uma troca.

Na segunda iteração do laço for o valor 20 será capturado, pois estaremos com i = 1. O valor 20 será comparado com o

valor de i+1 (2), que no caso é o valor 30. Então se 20 > 30 a troca será realizada. Como 20 não é maior que 30 não

entraremos na condição e o laço for continuará a ser executado, agora na próxima iteração, onde i = 2.

Quando i = 2 já estamos no último elemento, então não entrará no laço for, já que i não é menor que vetor.length – 1. Se

fosse possível entrar no último elemento para realizar comparações o seguinte erro aconteceria:

Except i on i n t hread "mai n" j ava. l ang. Ar r ayI ndexOutOf BoundsExcept i on:

Isso porque não podemos realizar a operação de comparação do último elemento com um próximo elemento, já que ele não

existe.

Porque a variável troca é útil? Ao passar pela primeira vez no vetor de elementos qualquer troca que for realizada ativa a

variável troca como true, fazendo com que ele precise passar novamente depois da leitura de todos os elementos. A ideia é

passar quantas vezes forem necessárias até que a variável troca não seja mais ativada, assim saberemos que todos os

elementos estão devidamente ordenados.





Analisando mais a fundo o algoritmo BubbleSort você perceberá que a segunda passada geralmente será muito mais rápida

que a primeira, principalmente se todo o vetor já foi ordenado corretamente, fazendo com que nenhuma vez seja

necessário realizar trocas, assim o mesmo entra no “melhor caso”, ou seja, todos os valores ordenados.

BubbleSort

Elementos Caso médio (n²) Melhor Caso (n)

100 0 ms 0 ms

1.000 15 ms 0 ms

10.000 200 ms 0 ms

100.000 20.426 ms 2 ms

200.000 81.659 ms 4 ms

Tabela 2. Medição de Tempo para BubbleSort

Analisando a Tabela 2 podemos perceber que até 1000 elementos o BubbleSort é eficiente e realiza a ordenação de forma

eficaz, porém com valores maiores já se torna mais lento. No melhor caso quase não há alteração para o tempo de

resposta deste algoritmo, visto que ele apenas passará dentro do laço for sem entrar nenhuma vez na condição para

realizar a troca de elementos.

QuickSort

Este algoritmo usa uma técnica conhecida por divisão e conquista, muito conhecida por reduzir problemas complexos em

problemas menores para tentar chegar em uma solução. Sendo assim, o resultado do problema inicial é dada como a soma

do resultado de todos os problemas menores. Sua complexidade é:


Complexidade Caso Médio: (nlogn)Complexidade Melhor Caso: (nlogn)

O QuickSort sai na frente de outros algoritmos mais simples quando tratamos do caso médio, por trabalhar com logaritmo

(nlogn), o que torna o resultado mais rápido do que o InsertionSort e o QuickSort.

O algoritmo consiste nos seguintes passos:

1. Escolhe-se um elemento qualquer da lista, que será chamado de pivô.

2. Todos os elementos antes do pivô devem ser menores que ele e todos os elementos após o pivô devem ser maiores

que ele. Quando esse processo de separação for finalizado, então o pivô deve estar exatamente no meio da lista.

3. De forma recursiva os elementos da sublista menor e maiores são ordenados.





Seu algoritmo pode ser visto na Listagem 3.

Listagem 3. QuickSort





vet or [ i ] = ( i nt ) ( Mat h. r andom( ) *quant i dade) ;

}


qui ckSort ( vet or, 0, vet or. l engt h- 1) ;



}

pr i vat e stati c voi d qui ckSort ( i nt[ ] vet or , i nt i ni c i o, i nt f i m) {

i f ( i ni ci o < f i m) {

i nt posi caoPi vo = separar(vetor , i ni c i o, f i m);

qui ckSort ( vet or, i ni ci o, posi caoPi vo - 1) ;

qui ckSort ( vet or, posi caoPi vo + 1, f i m) ;

}

}

pr i vate s tat i c i nt separar ( i nt [ ] vetor , i nt i ni c i o, i nt f i m) {

i nt pi vo = vetor [ i ni c i o] ;

i nt i = i ni ci o + 1, f = f i m;

whi l e ( i <= f ) {

i f (vetor [ i ] <= pi vo)

i ++;

el se i f (p i vo < vetor [ f ] )

f - - ;

el se {

i nt t r oca = vetor [ i ] ;

vetor [ i ] = vetor [ f ] ;

vetor [ f ] = tr oca;

i ++;

f - - ;

}

}

vetor [ i ni c io ] = vetor [ f ] ;

vetor [ f ] = pi vo;

return f ;

}

O primeiro passo é separar as listas, como havíamos citado anteriormente. No método separar() esse processo é realizado

até que seja retornado um pivô, ou seja, o elemento divisível entre as duas listas.





Finalizado o processo de separação então é chamado um próprio método quickSort() de forma recursiva, onde ele fará o

processo de separação interna dentro da sublista e assim será feito até que todos os elementos estejam ordenados.

Se você preferir, na Listagem 4 também temos um pseudocódigo que exemplifica o funcionamento do QuickSort em

linguagem genérica.

Listagem 4. Pseudocódigo quicksort

pr ocedi ment o Qui ckSor t ( X[ ] , I ni Vet, Fi mVet)

var

i , j , pi vo, aux

i ní ci o

i <- I ni Vet

j <- Fi mVet

pi vo <- X[ ( I ni Vet + Fi mVet ) di v 2]

enquant o( i < j )

| enquant o ( X[ i ] < pi vo) f aça

| | i <- i + 1

| f i mEnquant o

| enquant o ( X[ j ] > pi vo) f aça

| | j <- j - 1

| f i mEnquant o

| se ( i <= j ) ent ão

| | aux <- X[ i ]

| | X[ i ] <- X[ j ]

| | X[ j ] <- aux

| | i <- i + 1

| | j <- j - 1

| f i mSe

f i mEnquant o se ( j > I ni Vet ) ent ão

| Qui ckSort (X, I ni Vet , j )

f i mSe

se ( i < Fi mVet ) ent ão

| Qui ckSor t ( X, i , Fi mVet )

f i mse

f i mprocedi ment o

O QuickSort é um algoritmo mais robusto e complexo que os mostrados anteriormente, por isso achamos importante

exemplificar o seu uso através do pseudocódigo.

Vejamos na Tabela 3 a comparação entre o tempo de execução.

QuickSort

Elementos Caso médio (nlogn)

100 0 ms

1.000 0 ms

10.000 39 ms





100.000 43 ms

200.000 50 ms

Tabela 3. Medição do Tempo de execução para QuickSort

Veja que o tempo de processamento do QuickSort é muito bom quando tratamos do caso médio, que é exatamente o nosso

caso (randômico). Veja que o tempo para 200.000 registros é muito eficiente, muito mais que os mostrados anteriormente

para este tipo de caso.

Com isso, vimos que em se tratando de simplicidade, o BubbleSort é o melhor, visto que sua implementação e lógica são

simples e eficazes para uma pequena quantidade de valores, porém precisamos de algoritmos mais robustos quando

sabemos que a entrada se dará para uma grande quantidade de valores.

Por outro lado, o InsertionSort não é tão complexo quanto o QuickSort, mas também não é tão simples quanto o BubbleSort,

acrescentando um pouco mais de robustez e consequentemente desempenho na ordenação de valores. O InsertionSort é

um meio termo e possibilita a ordenação de valores um pouco maiores que o BubbleSort, mas também não consegue

ordenar uma grande quantidade de valores igual ao QuickSort, que por sua vez, mostrou-se o algoritmo mais rápido de

todos e consequentemente o mais complexo de ser implementado. Isso ocorre principalmente pelo fato de ele trabalhar

com recursos como recursividade para alcançar um desempenho notável.

É perceptível que o QuickSort, BubbleSort e InsertionSort possuem quase o mesmo tempo de resposta quando estamos

tratando com até 1000 elementos no vetor, a variação é tão insignificante que a escolha de um destes algoritmos é mais uma questão pessoal do que profissional.

Ao trabalhar com uma quantidade de valores maior, já percebemos que algoritmos simples podem não ser a melhor

escolha, você mesmo pode fazer um teste tentando executar o BubbleSort para um milhão de elementos. Se para 200.000

elementos o tempo de resposta foi quase 82 segundos e o mesmo cresce de forma exponencial, então para um milhão de

elementos possivelmente chegará perto ou passará (dependendo do hardware) de horas.

Testamos de forma exaustiva o algoritmo QuickSort para o melhor caso com 100 elementos no vetor, e constatamos que em alguns momentos ocorrem alguns picos de velocidade onde o retorno muda de 1ms para 5ms, apontando uma pequena

perda de desempenho. Testando a mesma quantidade de elementos para o melhor caso no BubbleSort a variável não

ocorreu nenhuma vez, mantendo a velocidade sempre em 1ms. Apontando um ponto positivo para o algoritmo mais simples

em casos específicos.

Ronaldo Lanhellas

Bacharel em Ciência da Computação (UNAMA). Cursando Pós-Graduação em Tecnologias WEB (UFPA). Trabalhando atualmente como Analista de

Sistemas Java.

http://www.devmedia.com.br/autor/ronaldo-lanhellas/244531







Gostei (3) (0)

O que você achou deste post?

Postar dúvida / Comentário

Publicado em 2015

Mais conteúdo sobre Java

Todos os comentarios (4)

Meus comentarios

Wellington Dantas Pereira

Muito interessante, mas como eu descubro o tempo que o algoritmo levou para ordenar meu array? **utilizo o netbeans

[há +1 mês] - Responder

Douglas Claudio

Olá Wellington, obrigado pelo seu comentário.

Enviamos sua solicitação ao Ronaldo e estamos no aguardo de um feedback do mesmo.

Um abraço.


Wellington Dantas Pereira

haha obrigado pela atenção, mas não há mais necessidade.

Consegui entender o funcionamento, faltou mesmo foi atenção da minha parte rs.

Caso alguem tenha a mesma dúvida, basta se atentar na utilização do System.currentTimeMillis().


Douglas Claudio

Olá Wellington,

Qualquer problema conte conosco e obrigado por compartilhar a sua solução.

Um abraço.


Publicidade

MVP

MVP

http://www.devmedia.com.br/rte3/addcomment.asp?idcomp=32693

http://www.devmedia.com.br/java

http://www.devmedia.com.br/meus-comentarios/

http://www.devmedia.com.br/rte3/addcomment.asp?idcomp=32693&idco_pai=61353








http://www.devmedia.com.br/meus-comentarios/



http://www.devmedia.com.br/rte3/addcomment.asp?idcomp=32693





Mais postsArtigo

Introdução ao Facelets

Artigo

Conheça o conceito Mônada no Java

Artigo

Programação Orientada a Objetos versus Programação Estruturada

Artigo

Raspberry Pi e a biblioteca Java RxTx

Artigo

CRUD completo com Hibernate e JPA

Artigo

Baixo Acoplamento com DAO

Artigo

Programação Restritiva: usando boas práticas em Java

Artigo

Conheça a Arquitetura Lambda em Java

Artigo

Profiling: Como analisar Aplicações Java

JAVA JSF

JAVA

JAVA .NET PROGRAMAÇÃO

JAVA RASPBERRY RXTX

JAVA JPA CRUD HIBERNATE

JAVA DAO

JAVA BOAS PRATICAS

JAVA LAMBDA BIGDATA

JAVA

http://www.devmedia.com.br/introducao-ao-facelets/5332

http://www.devmedia.com.br/conheca-o-conceito-monada-no-java/32838

http://www.devmedia.com.br/programacao-orientada-a-objetos-versus-programacao-estruturada/32813

http://www.devmedia.com.br/raspberry-pi-e-a-biblioteca-java-rxtx/32722

http://www.devmedia.com.br/crud-completo-com-hibernate-e-jpa/32711

http://www.devmedia.com.br/baixo-acoplamento-com-dao/32696

http://www.devmedia.com.br/programacao-restritiva-usando-boas-praticas-em-java/32651

http://www.devmedia.com.br/conheca-a-arquitetura-lambda-em-java/32646

http://www.devmedia.com.br/profiling-como-analisar-aplicacoes-java/32500

http://www.devmedia.com.br/profiling-como-analisar-aplicacoes-java/32500

http://www.devmedia.com.br/conheca-a-arquitetura-lambda-em-java/32646

http://www.devmedia.com.br/programacao-restritiva-usando-boas-praticas-em-java/32651

http://www.devmedia.com.br/baixo-acoplamento-com-dao/32696

http://www.devmedia.com.br/crud-completo-com-hibernate-e-jpa/32711

http://www.devmedia.com.br/raspberry-pi-e-a-biblioteca-java-rxtx/32722

http://www.devmedia.com.br/programacao-orientada-a-objetos-versus-programacao-estruturada/32813

http://www.devmedia.com.br/conheca-o-conceito-monada-no-java/32838

http://www.devmedia.com.br/introducao-ao-facelets/5332

http://www.devmedia.com.br/campanha/v.asp?i=129




Listar mais conteúdo

Anuncie | Loja | Publique | Assine | Fale conosco

Hospedagem web por Porta 80 Web Hosting


http://www.web-03.net/devmedia.asp

http://www.devmedia.com.br/shop/

http://www.devmedia.com.br/seja-um-autor-devmedia/28103


http://www.devmedia.com.br/fale-conosco/

http://www.porta80.com.br/




http://www.devmedia.com.br/fale-conosco/


http://www.devmedia.com.br/seja-um-autor-devmedia/28103

http://www.devmedia.com.br/shop/

http://www.web-03.net/devmedia.asp

http://www.devmedia.com.br/feed/

http://www.devmedia.com.br/feed/

https://plus.google.com/101753743720604160232?prsrc=3

https://plus.google.com/101753743720604160232?prsrc=3

http://twitter.com/devmedia

http://twitter.com/devmedia

http://www.facebook.com/pages/DevMedia/144522665592650

http://www.facebook.com/pages/DevMedia/144522665592650


Documents

Algoritmos de Ordenação Em Java