Pessoal, preciso fazer uma ordenação, caiu hoje em uma prova, infelizmente não consegui fazer, a questão era o seguinte, Ler 10 numeros (li com Joptionpane) e ordenar em ordem crescente.
como seria a lógica?
[quote=kvnallen]Pessoal, preciso fazer uma ordenação, caiu hoje em uma prova, infelizmente não consegui fazer, a questão era o seguinte, Ler 10 numeros (li com Joptionpane) e ordenar em ordem crescente.
como seria a lógica?[/quote]
O algoritmo de Bubble sort é simples e de fácil compreensão. Dá uma lida nele e aplique-o. Na internet, tem n exemplos de implementado, minha recomendação é que tente faze-lo sem ver ele pronto, caso contrário, pode “se dar mal” na próxima prova novamente.
Abraços.
Depende de que prova você está fazendo, é de Java ou de Algoritmos?
Se for algo mais voltado para algoritmos concordo plenamente com o que o colega nel postou e é algo para você entender a ordenação.
Mas se for uma prova de java que pode usar todos seus recursos e esteja com falta de tempo para terminar a prova, tem algo como o código abaixo, é só executar:
[code]import java.util.*;
public class Hello {
public static void main(String[] args) {
int[] num = {2, 3, 1, 7, 9, 4, 8, 10, 6, 5};
System.out.println("Atual:");
for (int aux : num) {
System.out.print(aux + " ");
}
Arrays.sort(num);
System.out.println("\nOrdenado:");
for (int aux : num) {
System.out.print(aux + " ");
}
}
}[/code]
Quando entrei em uma consultoria, há um tempão atrás, uma das questões da prova era exatamente essa (ordenar algo), e o jeito que usei para responder era exatamente esse (usei o BubbleSort mesmo).
A prova era em C (não em Java - naquele tempo o Java não existia) .
A diferença é que a prova era com consulta (ao livro do Kernighan e Ritchie) e casualmente o livro tinha o código do QuickSort, mas nem tinha percebido isso , porque, apesar de saber o livro “mais ou menos” de cor (era uma edição antiga e bem curtinha) eu simplesmente nem abri o livro, e tinha esquecido completamente que ele tinha esse código. (Como era uma versão traduzida, fiquei com um pouco de receio até de abrir o livro - provavelmente ela ia me confundir mais que me ajudar. )
Dica: saiba um dos métodos “simples” de ordenação de cor, como o Insertion Sort ou o Bubble Sort. Ele pode lhe salvar a vida 
[quote=entanglement]Quando entrei em uma consultoria, há um tempão atrás, uma das questões da prova era exatamente essa (ordenar algo), e o jeito que usei para responder era exatamente esse (usei o BubbleSort mesmo).
A prova era em C (não em Java - naquele tempo o Java não existia) .
A diferença é que a prova era com consulta (ao livro do Kernighan e Ritchie) e casualmente o livro tinha o código do QuickSort, mas nem tinha percebido isso , porque, apesar de saber o livro “mais ou menos” de cor (era uma edição antiga e bem curtinha) eu simplesmente nem abri o livro, e tinha esquecido completamente que ele tinha esse código. (Como era uma versão traduzida, fiquei com um pouco de receio até de abrir o livro - provavelmente ela ia me confundir mais que me ajudar. )
Dica: saiba um dos métodos “simples” de ordenação de cor, como o Insertion Sort ou o Bubble Sort. Ele pode lhe salvar a vida
[/quote]
O quicksort também é um algorítmo fácil de entender e de memorizar 
Obs: Essa prova que você fez deve ter sido há um bom tempo mesmo, já que o Java nem existia 
[quote=Frantic Avenger]Depende de que prova você está fazendo, é de Java ou de Algoritmos?
Se for algo mais voltado para algoritmos concordo plenamente com o que o colega nel postou e é algo para você entender a ordenação.
Mas se for uma prova de java que pode usar todos seus recursos e esteja com falta de tempo para terminar a prova, tem algo como o código abaixo, é só executar:
[code]import java.util.*;
public class Hello {
public static void main(String[] args) {
int[] num = {2, 3, 1, 7, 9, 4, 8, 10, 6, 5};
System.out.println("Atual:");
for (int aux : num) {
System.out.print(aux + " ");
}
Arrays.sort(num);
System.out.println("\nOrdenado:");
for (int aux : num) {
System.out.print(aux + " ");
}
}
}[/code][/quote]
Legal, então é só usar o Arrays.sort(array) para organizar em ordem crescente? E em decrescente como seria?
Decrescente:
Arrays.sort(col, new Comparator<Integer>() {
@Override
public int compare(Integer t, Integer t1) {
return t1.compareTo(t);
}
});
Crescente:
Arrays.sort(col, new Comparator<Integer>() {
@Override
public int compare(Integer t, Integer t1) {
return t.compareTo(t1);
}
});
este assunto é interessante … Arrays.sort geralmente resolve.
mas em um trabalho fizemos isto na ‘mão’ ou sem métodos prontos.
e ficou bem legal. parece um código simples e pequeno, mas tem uma grande lógica por trás dele.
segue aí…
[code]
public class CopiaEOrdena_1_1_5 {
public static void main(String[] args) {
//int inteiros[]= new int[10];
int inteiros[] = {45, 67, 44, 33, 21, 76, 89, 12, 34, 22};
int inteiros2[] = new int[inteiros.length];
for (int i = 0; i < 10; i++) {
System.out.println("inteiro [" + i + "] = " + inteiros[i]);
}
for (int j = 0; j < inteiros.length; j++) {
int contaPosicao=0;
for (int i = 0; i < inteiros.length; i++) {
if (inteiros[j] > inteiros[i]) {
contaPosicao=contaPosicao+1;
}
}
inteiros2[contaPosicao]=inteiros[j];
}
for (int i = 0; i < inteiros2.length; i++) {
System.out.println("inteiros2 [" + i + "] = " + inteiros2[i]);
}
}
}[/code]
pode mudar o array, para ver como ele acha e ordena os números…
na verdade é um pouco complicado de entender. fui entender o que fiz, tive que por os system.out. print porque fica mais fácil…
segue aí com system.out.println… para entender a lógica do programa…
[code]
/*
- To change this template, choose Tools | Templates
- and open the template in the editor.
*/
package sobrasdotrabalho;
public class CopiaEOrdena_1_1_5 {
public static void main(String[] args) {
//int inteiros[]= new int[10];
int inteiros[] = {45, 67, 44, 33, 21, 76, 89, 12, 34, 22};
int inteiros2[] = new int[inteiros.length];
for (int i = 0; i < 10; i++) {
System.out.println("inteiro [" + i + "] = " + inteiros[i]);
}
for (int j = 0; j < inteiros.length; j++) {
int contaPosicao=0;
for (int i = 0; i < inteiros.length; i++) {
if (inteiros[j] > inteiros[i]) {
System.out.println("inteiros[j]"+inteiros[j]+" > " +inteiros[i]+"inteiros[i]");
contaPosicao=contaPosicao+1;
}
// System.out.println(" contaposicao "+contaPosicao);
}
// System.out.println(" inteiros2[contaPosicao] 1: "+ inteiros2[contaPosicao]);
inteiros2[contaPosicao]=inteiros[j];
System.out.println(" inteiros2[contaPosicao : "+contaPosicao+"] 1: "+ inteiros2[contaPosicao]);
}
for (int i = 0; i < inteiros2.length; i++) {
System.out.println("inteiros2 [" + i + "] = " + inteiros2[i]);
}
}
}[/code]
ou seja ele vai ver um por um , qual é a posição ou quantos números existem menores que ele em outras palavras,
e a cada número ele ve a posição certa… do número que está olhando. já que temos dois ‘for’ um de todo o número e um de todo número comparado com cada um, da mesma lista. … parecido com imprimir matrizes bidimensionais… (outro assunto).
run:
inteiro [0] = 45
inteiro [1] = 67
inteiro [2] = 44
inteiro [3] = 33
inteiro [4] = 21
inteiro [5] = 76
inteiro [6] = 89
inteiro [7] = 12
inteiro [8] = 34
inteiro [9] = 22
inteiros[j]45 > 44inteiros[i]
inteiros[j]45 > 33inteiros[i]
inteiros[j]45 > 21inteiros[i]
inteiros[j]45 > 12inteiros[i]
inteiros[j]45 > 34inteiros[i]
inteiros[j]45 > 22inteiros[i]
inteiros2[contaPosicao : 6] 1: 45
inteiros[j]67 > 45inteiros[i]
inteiros[j]67 > 44inteiros[i]
inteiros[j]67 > 33inteiros[i]
inteiros[j]67 > 21inteiros[i]
inteiros[j]67 > 12inteiros[i]
inteiros[j]67 > 34inteiros[i]
inteiros[j]67 > 22inteiros[i]
inteiros2[contaPosicao : 7] 1: 67
inteiros[j]44 > 33inteiros[i]
inteiros[j]44 > 21inteiros[i]
inteiros[j]44 > 12inteiros[i]
inteiros[j]44 > 34inteiros[i]
inteiros[j]44 > 22inteiros[i]
inteiros2[contaPosicao : 5] 1: 44
inteiros[j]33 > 21inteiros[i]
inteiros[j]33 > 12inteiros[i]
inteiros[j]33 > 22inteiros[i]
inteiros2[contaPosicao : 3] 1: 33
inteiros[j]21 > 12inteiros[i]
inteiros2[contaPosicao : 1] 1: 21
inteiros[j]76 > 45inteiros[i]
inteiros[j]76 > 67inteiros[i]
inteiros[j]76 > 44inteiros[i]
inteiros[j]76 > 33inteiros[i]
inteiros[j]76 > 21inteiros[i]
inteiros[j]76 > 12inteiros[i]
inteiros[j]76 > 34inteiros[i]
inteiros[j]76 > 22inteiros[i]
inteiros2[contaPosicao : 8] 1: 76
inteiros[j]89 > 45inteiros[i]
inteiros[j]89 > 67inteiros[i]
inteiros[j]89 > 44inteiros[i]
inteiros[j]89 > 33inteiros[i]
inteiros[j]89 > 21inteiros[i]
inteiros[j]89 > 76inteiros[i]
inteiros[j]89 > 12inteiros[i]
inteiros[j]89 > 34inteiros[i]
inteiros[j]89 > 22inteiros[i]
inteiros2[contaPosicao : 9] 1: 89
inteiros2[contaPosicao : 0] 1: 12
inteiros[j]34 > 33inteiros[i]
inteiros[j]34 > 21inteiros[i]
inteiros[j]34 > 12inteiros[i]
inteiros[j]34 > 22inteiros[i]
inteiros2[contaPosicao : 4] 1: 34
inteiros[j]22 > 21inteiros[i]
inteiros[j]22 > 12inteiros[i]
inteiros2[contaPosicao : 2] 1: 22
inteiros2 [0] = 12
inteiros2 [1] = 21
inteiros2 [2] = 22
inteiros2 [3] = 33
inteiros2 [4] = 34
inteiros2 [5] = 44
inteiros2 [6] = 45
inteiros2 [7] = 67
inteiros2 [8] = 76
inteiros2 [9] = 89
Tem vários algoritmos de ordenação que necessitam dividir o array em partes e fazer comparações em cada parte, mas existe uma técnica que aprimora as comparações, chama-se Tukey’s ninther
http://www.johndcook.com/blog/2009/06/23/tukey-median-ninther/
Basicamente consiste em pegar os 9 primeiros elementos do array e dividi-los em 3 grupos de 3, obter a mediana dos 3, assim serão 3 medianas e então você obtém a mediana desses 3 elementos, este valor será a mediana aproximada dos 9 elementos sem precisar comparar todos.
array: 2,7,9,4,5,1,3,6,10
grupo 1: 2 - 7 - 9 -> mediana: 7
grupo 2: 4 - 5 - 1 -> mediana: 5
grupo 3: 3 - 6 - 10 -> mediana: 6
grupo das medianas: 7 - 5 - 6 -> mediana: 6
array ordernado: 1,2,3,4,5,6,7,9,10
ou seja, sem quase nenhuma comparação, você sabe aproximadamente qual o valor para dividir o array.