Seguinte to elaborando um programinha que ele aprensenta o menor e maior numero mais como posos fazer isso?quero que ele automaticamente defina pensei em fazer uma ordenação do menor para o maior mais não consegui representa apenas o menor e maior
==================================>>>>>>>>>>>>>>>
Codigo Duvida
<<<<<<<<<<<<<<<<=================================
class Maior e Menor{
public static void main (String [] args){
int numero = 15;
int numero2 = 26;
int numero3 = 12;
int numero4 = 10;
int numero5 = 55;
}
}
==============================================>>
Fim do Codigo
<<=============================================
Com arrays eu sei fazer xD só dessa forna sem arrays que eu naum cosigo fazer =/… pq nunca me deparei com uam dessas comparar variavel por variavel e apresentar maior e menor! se pode ajudar ae vei agradeço fiko grato ou poder me daruma dica de como fazer jah ajuda abraço!
Amigo, sem arrays você pode fazer como se fosse uma tabelinha de futebol. Vai ficar um programa meio grande, mas é um exercício (trabalhoso mas é um exercício).
Em vez de "numero", "numero2" etc. use "vasco", "flamengo", "corinthians", "palmeiras", "remo" ou os times de sua preferência , e faça os jogos, como se fosse um tipo de "mata-mata". Se vasco > flamengo, então vasco ganhou, então você procede ao próximo par de times (corinthians x palmeiras)
Entendeu direitinho?
Ah entendi tip comparar um a um ate chegara uma final e tals pensei nisso mais sei lah pensie ke tinha uma forma ke jah comparava todos e apresentava mais ok valeu agradeço mesmo xD
Usei Array mesmo xD
import java.util.Arrays;
class Pag59a{
public static void main(String[]args){
String retorno;
int[] listanumeros = new int[5];
listanumeros[0]=15;
listanumeros[1]=30;
listanumeros[2]=50;
listanumeros[3]=05;
listanumeros[4]=03;
System.out.println(“Numeros Ordenados”);
System.out.println("");
Arrays.sort(listanumeros);
System.out.print(“Resultado===>>”);
for(int i=0; i<listanumeros.length; i++){
System.out.print(listanumeros[i]+",");
}
}
}
Acho que o que vc precisa é isso:
int menor = Integer.MAX_VALUE;
int maior = Integer.MIN_VALUE;
int[] listanumeros = new int[5];
listanumeros[0]=15;
listanumeros[1]=30;
listanumeros[2]=50;
listanumeros[3]=05;
listanumeros[4]=03;
for(int i=0; i<listanumeros.length; i++){
if (listanumeros[i]><menor) menor = listanumeros[i];
if (listanumeros[i]><maior) maior = listanumeros[i];
}
System.out.print("Maior = ");
System.out.println(maior);
System.out.print("Menor = ");
System.out.println(menor);
mostra apenas o maior e o menor
É claro que existe “Collections.max” e “Collections.min”, mas o professor do cara não vai aceitar isso - ele quer uma solução como a do Ricardo.
O codigo do ricardo esta perfeito. Nao precisa ordenar!! Mas ainda da pra melhorar.
Ele faz praticamente 2*n comparacoes… da pra fazer com uma quantidade menor que isso de comparacoes. Quem se atreve?
Dá para fazer usando a tal tabela do campeonato e os mata-matas. (Fazendo desse jeito você precisa fazer algumas continhas, mas não é nada absurdo).
Dou a idéia para que o pessoal possa aprimorar.
Tentei implementar uma solução com maior performance mas não funcionou…
Seria algo como N*logN ???
[]'s
Nao
É 3n/2. Beeeeeeem melhor que nlogn.
Alguem aqui tinha digitado um codigo e chegado perto… Bricando meia hora la na caelum pra lembrar como era isso…
[quote=Paulo Silveira]Nao
É 3n/2. Beeeeeeem melhor que nlogn.
Alguem aqui tinha digitado um codigo e chegado perto… Bricando meia hora la na caelum pra lembrar como era isso…[/quote]
Eu cheguei a postar um código q eu fiz aqui, mas depois de analisar melhor, ví que ele não era tão bom qto o do Ricardo … por isso tirei :oops:
Paulo …
Tentei, mas não conseguí … como seria possível implementar algo com complexidade 3N/2 ???
[]'s
Da pra alterar o código pra ficar assim, 3n/2 -1 comparações em média, n-1 no melhor caso e 2n -2 no pior (atenção: a pressa junto com o sono podem gerar conclusões erradas sobre o número de comparações 
)
int menor = listanumeros[0];
int maior = listanumeros[0];
for (int i = 1; i < listanumeros.length; i++) {
if (listanumeros[i] < menor) {
menor = listanumeros[i];
} else if (listanumeros[i] > maior) {
maior = listanumeros[i];
}
}
da pra fazer (3n/2)-2 no pior caso 
acho que é legal de blogar. nao encontrei referencias em portugues.
[quote=Paulo Silveira]da pra fazer (3n/2)-2 no pior caso
acho que é legal de blogar. nao encontrei referencias em portugues.
[/quote]
O Sr. poderia então fazê-lo logo, porque ontem fiquei uma hora da minha vida pensando no 3n/2 e não cheguei a lugar algum. 
Consegui diminuir o número de iterações pela metade, mas aumentou a quantidade de comparações, fazendo com que a performance não fosse melhorada.
Para a quantidade de elementos do array abaixo, eu tive que alocar 500mb para a máquina virtual, pois estava dando estouro de memória.
Fiz uma classe com métodos estáticos só para testar.
[code]
import java.util.*;
public class Main {
public static void main( String[] args ) {
int[] array = new int[ 100000000 ];
int menorR;
int menorD;
populaArray( array );
long inicio = System.currentTimeMillis();
menorR = menorRapido( array );
long meio = System.currentTimeMillis();
menorD = menorDevagar( array );
long fim = System.currentTimeMillis();
System.out.println( "Utilizando metodo rapido\n" +
"Menor = " + menorR + "\n" +
"tempo gasto em milisegundos = " + ( meio - inicio ) );
System.out.println( "Utilizando metodo denavagar\n" +
"Menor = " + menorD + "\n" +
"tempo gasto em milisegundos = " + ( fim - meio) );
}
public static int menorRapido( int[] array ) {
int menor = array[array.length-1];
for( int i = 1; i < array.length; i+=2) {
if ( array[i-1] < array[i] && menor > array[i-1] )
menor = array[i-1];
else if ( menor > array[i] )
menor = array[i];
}
return menor;
}
public static int menorDevagar( int[] array ) {
int menor = array[0];
for( int i = 1; i < array.length; i++) {
if ( menor > array[i] )
menor = array[i];
}
return menor;
}
public static void populaArray( int[] array ) {
Random r = new Random();
for ( int i = 0; i < array.length; i++ ) {
array[i] = r.nextInt( 10000 );
}
}
}[/code]
Cheguei perto? :?:
Certamente a solução “Collections” é a mais apropriada pro dia-a-dia. Deixa o código limpo e, tenho o palpite de que, internamente ela realiza as mesmas operações que eu apresentei.
Mas, como foi dito, creio que se trata de uma tarefa para curso. Lembro-me de ter feito esses exercícios na facul, em Pascal, a alguns 10 anos atrás. E o professor deve estar pedindo algo assim.