Bubble Sort com Java

Este artigo tem como objetivo demonstrar a ordenação bubble sort, na linguagem java, mas independente da linguagem, este artigo orienta e demonstra como ocorre o bubble sort e explica alguns conceitos de java.

por Guilherme de Oliveira Santos

Introdução: Este artigo tem como objetivo orientar um usuário a realizar uma ordenação numérica simples (Bubble Sort), onde serão abordadas 2 classes pré-existentes no Java (import), utilizando-se também do conceito classe.método para obtenção de dados, estruturas (do, while, if , for e switch), declaração de vetor e alguns tipo de variáveis. Tendo em vista a aplicação de muitos conceitos iniciais do Java, para uma introdução no mundo Java.

Ferramentas utilizadas e link para Download:

NetBeans 7.0.1

http://netbeans.org/downloads/index.html

SDK 7

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Visualização do código em html : http://www.mediafire.com/?56ql8221534neam

Para melhor visualização do código.

Vamos abordar alguns conceitos utilizados aqui, neste tutorial. Para um melhor entendimento do todo. O que não for abordado aqui, é porque os comentários no código descrevem o que o mesmo faz perfeitamente.

IMPORT

import javax.swing.JOptionPane;

import java.lang.Math;

este comando (import) é utilizado para importar uma classe pré-existente no Java, para assim utilizarmos de seus métodos.

Estruturas

· if (Condiçao){}-> if é uma estrutura de decisão baseada na condição escrita dentro do (). Se a condição for atendedida, ele executa todo o código dentro das {}. Ex: if (vet[i]>vet[j]), se o vetor de índice i for maior que o vetor de índice j, ele executará o corpo dentro das {}.

· Do{ código

}while(condição) -> do while, é uma condição de faça(do) enquanto(while), sendo assim o código dentro das {} será repetido até fugir da condição do while.

Ex: do{código}while(menu!=9), o código será repetido até o valor da variável menu ser 9, pois a condição é faça(do) enquanto(while) for diferente (!=) de 9, então quando o valor for 9, ele atenderá a condição e sairá do laço de repetição.

· O while(condição) -> pode ser utilizado sozinho antes de uma parte do seu código fazendo assim ele executá-lo enquanto estiver na condição do while.

Ex: while(option!=1 && option!=2){codigo} enquanto for (!=)diferente de 1 (&&)ou 2 ele executará o que está dentro das {}

· switch (menu) { -> a estrutura switch, é uma estrutura de

case(x): código decisão, baseada no valor da variável

break;} menu(ou outra que desejar),conforme a atribuiçao da variável seguem as opções dentro dos cases(x) (x um valor que deseja como opção), sendo assim conforme a opção desejada ele percorre um código diferente. E o break, encerra a opção.

Ex: switch (menu) { // estrutura de decisão SWITCH

case (1): //Opção 1

OrdenaCrescente(); //Chamando o método OrdenaCrescente

break;//finaliza a opção

case (2): //Opção 2

OrdenaDecrescente();

... e assim em diante.

· for (valor inicial; valor final; soma ou subtração do valor ){código}

-> for é uma estrutura de repetição, onde ele irá repetir o código dentro das {}, até chegar ao seu valor final.

Valor inicial – ele inicia com um valor

Valor final – até quando esse código deve ser repetido

Soma ou subtração – soma ou subtração do valor inicial, tendo em vista que ele deve atingir o valor final.

Ex: for (i=0; i<(vet.length); i++){código}

Valor inicial- i=0

Valor final – tamanho do vetor (vet.length)

Soma ou subtração – soma de 1 em 1 ( i++)

Classe.Método

Neste tutorial utilizamos desta abordagem classe.metodo.

Ex: vet.length, vet é a variável de referencia do vetor, e length é um método pertencente a classe vetor para coletar o tamanho do mesmo.

Explicação de como funciona o bubble sort.

Baseado na ordenação crescente segue o código

for(i=0; i<(vet.length)-1; i++){ // o I só será somado quando acabar o laço J

for(j=i+1; j<(vet.length); j++){

if (vet[i]>vet[j]) {

aux=vet[i];

vet[i]=vet[j];

vet[j]=aux;

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

}//fim da estrutura for de indice i

Vet.length ( tamnho do vetor =5)

I- inicia com 0 cor VERDE

J- inicia com i+1 (se i for 0 j sera 1, se i for 2 j sera 3) cor VERMELHA

Índices do vetor

0 1 2 3 4

5

2

1

7

8

I-está no índice 0 (for do i)

j-está no índice 1 (for do j)

comparando (if) – numero do I é maior do que o de J ???

sim.

Então trocamos.

if (vet[i]>vet[j]) {

aux=vet[i];

vet[i]=vet[j];

vet[j]=aux;

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

2

5

1

7

8

I-está no índice 0 (for do i)

j-está no índice 2 (for do j)

comparando (if) – numero do I é maior do que o de J ???

sim.

Então trocamos.

if (vet[i]>vet[j]) {

aux=vet[i];

vet[i]=vet[j];

vet[j]=aux;

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

1

5

2

7

8

I-está no índice 0 (for do i)

j-está no índice 3 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

1

5

2

7

8

I-está no índice 0 (for do i)

j-está no índice 4 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J, J ultrapasso o valor final. Agora ele sairá do laço J.

}após sair do laço j, será acrescido 1 ao I, e J iniciará novamente com seu valor inicial, tendo em vista que I será 1 e J é I+1, J iniciará com o valor de 2.

0 1 2 3 4

1

5

2

7

8

I-está no índice 1 (for do i)

j-está no índice 2 (for do j)

comparando (if) – numero do I é maior do que o de J ???

sim.

Então trocamos.

if (vet[i]>vet[j]) {

aux=vet[i];

vet[i]=vet[j];

vet[j]=aux;

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

1

2

5

7

8

I-está no índice 1 (for do i)

j-está no índice 3 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

1

2

5

7

8

I-está no índice 1 (for do i)

j-está no índice 4 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J, J ultrapasso o valor final. Agora ele sairá do laço J.

}após sair do laço j, será acrescido 1 ao I, e J iniciará novamente com seu valor inicial, tendo em vista que I será 2 e J é I+1, J iniciará com o valor de 3.

0 1 2 3 4

1

2

5

7

8

I-está no índice 2 (for do i)

j-está no índice 3 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J

}

0 1 2 3 4

1

2

5

7

8

I-está no índice 2 (for do i)

j-está no índice 4 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J, J ultrapasso o valor final. Agora ele sairá do laço J.

}após sair do laço j, será acrescido 1 ao I, e J iniciará novamente com seu valor inicial, tendo em vista que I será 3 e J é I+1, J iniciará com o valor de 4.

0 1 2 3 4

1

2

5

7

8

I-está no índice 2 (for do i)

j-está no índice 4 (for do j)

comparando (if) – numero do I é maior do que o de J ???

não.

Então não executamos o código dentro do if, portanto não efetuamos a troca

if (vet[i]>vet[j]) {

pula o código porque não atende a condição

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

Soma 1 ao J, J ultrapasso o valor final. Agora ele sairá do laço J.

}após sair do laço j, será acrescido 1 ao I, I ultrapassou o valor final, agora ele sai do laço I, portanto acaba todo a estrutura de repetição encadeada ( encadeada = uma estrutura dentro da outra).

COMEÇANDO O PROJETO

Abra sua IDE e crie um novo Projeto em Java.

escolha a categoria Java, projetos aplicativo Java.

Atribua um nome ao seu projeto, aqui utilizamos Ordem.

Certo, agora que você já abriu seu projeto, vamos seguir com a codificaçao da nossa ordenação simples (bubble sort).

Vou separar o corpo do código, em métodos, para uma maior facilidade de interpretação, mas no inicio do tutorial segue o link, para download do código em html para uma melhor visualização e entendimento.

O que está em verde, são comentarios em cima do código para melhor compreenção do mesmo.

Segue declaração da classe Ordem e método principal.

@author Guilherme O. Santos

import javax.swing.JOptionPane; // importando uma classe pré existente no java

import java.lang.Math; // importando uma classe pré existente no java

public class Ordem { //declaração da classe com o nome identico ao do projeto

static int i,j,aux,menu,option; //declarando variáveis do tipo INTEIRO

static int vet[] = new int[10]; // declarando um vetor do tipo INTEIRO

public static void main(String[] args){ //método principal

Inserir(); //Chamando o método inserir

do{ //estrutura de repetição FAÇA

menu = Integer.parseInt(JOptionPane.showInputDialog ("INSIRA O Nº CORRESPONDENTE A OPERAÇAO:\n\n" //Introduçao de dados na variável de controle MENU através de uma interface.

+ "1 - Ordenar em ordem Crescente.\n"

+ "2 - Ordenar em ordem Decrescente.\n"

+ "3 - Inserir novos valores.\n"

+ "4 - Simular novos valores\n"

+ " 9 - Sair.")); // Opçoes correspondentes a estrutura de decisão SWITCH abaixo.

switch (menu) { // estrutura de decisão SWITCH

case (1): //Opção 1

OrdenaCrescente(); //Chamando o método OrdenaCrescente

break;//finaliza a opção

case (2): //Opção 2

OrdenaDecrescente(); //Chamando o método OrdenaDecrescente

break;//finaliza a opção

case (3): //Opção 3

InserirValor(); //Chamando o método InserirValor

break;//finaliza a opção

case(4): //Opção 4

Random(); //Chamando o método Random

break;//finaliza a opção

case (9): //Opção 5

System.exit(0); //Chamando o método exit da classe system (classe.método = System.exit())

break;//finaliza a opção

}//fim do switch

}while(menu!=9); //estrutura de repetição while associada ao DO, DO WHILE ( faça enquanto a condiçao for verdadeira)

//fim do DO.

}//fim do método principal

Segue declaração do método Inserir ()

/*método para inserir dados no vetor vet[]

* dando a opção de escolher os numeros

* ou sortia-los.

*/

private static void Inserir(){ //declaraçao do metodo Inserir

while(option!=1 && option!=2){ //estrutura de repetição While (Enquanto)

option = Integer.parseInt(JOptionPane.showInputDialog ("INSIRA O Nº CORRESPONDENTE A OPERAÇAO:\n\n"//Introduçao de dados na variável de controle OPTION através de uma interface.

+ "1 - Inserir novos valores\n"

+ "2 - Simular novos valor"));// Opçoes correspondentes a estrutura de decisão SWITCH abaixo.

switch (option) {// estrutura de decisão SWITCH

case(1): InserirValor(); //Chamando o método InserirValor

break;//finaliza a opção

case(2): Random(); //Chamando o método Random

break;//finaliza a opção

} //fim do switch

}// fim do while (enquanto)

}//fim do metodo Inserir()

Segue declaração do método InserirValor()

/*

*metodo para inserir valores manualmente no vetor vet[]

*/

private static void InserirValor(){ //declaraçao do metodo Inserir

for (i=0; i<(vet.length); i++) { //estrutura de repetição FOR ( para )

aux= i + 1;// atribuiçao do valor de i + 1 na variavel aux

vet[i] = Integer.parseInt(JOptionPane.showInputDialog("insira o "+aux+"º valor:"));//Introduçao de dados no vetor vet[i] tendo i como indice.

}//fim da estrutura for

JOptionPane.showMessageDialog(null,"os valores são: ["// exibiçao de dados atravez de uma interface

+vet[0]+","+vet[1]+","+vet[2]+","+vet[3]+","+vet[4]+","+vet[5]+","+vet[6]+","+vet[7]+","+vet[8]+","+vet[9]+"]");

}//fim do metodo InserirValor()

Segue declaração do método Random()

/*

* metodo para inserir valores sortidos no vetor vet[]

*/

private static void Random(){//declaraçao do metodo Random()

long aux2=0;//declaraçao de variavel local do tipo LONG

for (i=0; i<(vet.length); i++) {//estrutura de repetição FOR ( para )

aux2 = Math.round(Math.random()*100); // atribuiçao de um valor sortido a variavel aux2

vet[i] =(int) aux2;//atribuiçao do valor de aux2 para vet[] de indice i. (int) serve para forçar o valor a ser um INTEIRO

}//fim da estrutura for

JOptionPane.showMessageDialog(null,"os valores são: ["// exibiçao de dados atravez de uma interface

+aux2+""+vet[0]+","+vet[1]+","+vet[2]+","+vet[3]+","+vet[4]+","+vet[5]+","+vet[6]+","+vet[7]+","+vet[8]+","+vet[9]+"]");

}//fim do metodo Random()

Segue declaração do método OrdenaCrescente()

/*

* metodo para ordenar os valores do vetor vet[] em ordem crescente

*/

public static void OrdenaCrescente(){//declaraçao do metodo OrdenaCrescente

for(i=0; i<(vet.length)-1; i++){//estrutura de repetição FOR ( para )

for(j=i+1; j<(vet.length); j++){//estrutura de repetição FOR ( para )

if (vet[i]>vet[j]) {//estrutura de decisao IF ( se(condiçao) ) se atender a condiçao executa todo o código dentro da estrutura

aux=vet[i];// aux recebe o valor do vet[] de indice i

vet[i]=vet[j];// vet[] de indice i recebe o valor do vet[] de indice j

vet[j]=aux;// vet[] de indice j recebe o valor do aux ( que era o valor do vet[] de indice i

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

}//fim da estrutura for de indice i

JOptionPane.showMessageDialog(null,"Os valores em Ordem Crescente: ["// exibiçao dos dados atravez de uma interface

+vet[0]+","+vet[1]+","+vet[2]+","+vet[3]+","+vet[4]+","+vet[5]+","+vet[6]+","+vet[7]+","+vet[8]+","+vet[9]+"]");

}//fim do metoro OrdenaCrescente()

Segue declaração do método OrdenaDecrescente()

/*metoro para ordenar os valores do vetor vet[] em ordem decrescente

*

*/

public static void OrdenaDecrescente(){//declaraçao do metodo OrdenaDecrescente

for(i=0; i<(vet.length)-1; i++){//estrutura de repetição FOR ( para )

for(j=i+1; j<(vet.length); j++){//estrutura de repetição FOR ( para )

if (vet[i]<vet[j]) {//estrutura de decisao IF ( se(condiçao) ) se atender a condiçao executa todo o código dentro da estrutura

aux=vet[i];// aux recebe o valor do vet[] de indice i

vet[i]=vet[j];// vet[] de indice i recebe o valor do vet[] de indice j

vet[j]=aux;// vet[] de indice j recebe o valor do aux ( que era o valor do vet[] de indice i

}//fim da estrutura IF (se)

}//fim da estrutura for de indice j

}//fim da estrutura for de indice i

JOptionPane.showMessageDialog(null,"Os valores em Ordem Decrescente: ["// exibiçao dos dados atravez de uma interface

+vet[0]+","+vet[1]+","+vet[2]+","+vet[3]+","+vet[4]+","+vet[5]+","+vet[6]+","+vet[7]+","+vet[8]+","+vet[9]+"]");

}//fim do metodo OrdenaDecrescente

}//fim da classe Ordem

Simulaçao utilizando o sorteio automático dos números.

Iniciado

Escolhi a opção 2 para sorteio dos números. ok

Números sorteados. ok

Menu de opções

Escolhi 1 para ordenar em ordem crescente. Ok

Ordenado em ordem crescente. Ok

Retorna ao menu.

Escolhi 2 para ordenar em ordem decrescente. Ok

Ordenado em ordem decrescente.ok

Retorna ao menu.

Escolhi a opção 9 para sair do programa. Ok

Programa finalizado.

É isso ae pessoal, espero que eu tenha ajudado vocês a compreenderem ordenação simples bubble sort.

Até mais.