Problemas com Ordenção

Estou com problema no seguinte código:

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int qtdeNum = 0;
		int arrayNoraml[];
		
		System.out.print("Digite o quantidade de números que será digitada: ");
		qtdeNum = scan.nextInt();
		arrayNoraml = new int[qtdeNum];		
		
		for (int i = 0; i < arrayNoraml.length; i++) {
			System.out.print("Digite o "+(i+1)+"° número: ");
			arrayNoraml[i] = scan.nextInt();
		}
		
		int arrayDecrescente[] = ordenaDecrescente(arrayNoraml);
		int arrayCrescente[] = ordenaCrescente(arrayNoraml);
		
		System.out.print("Array sem ordenação: ");
		escreveArray(arrayNoraml);
		System.out.print("Array ordenado crescentemente: ");
		escreveArray(arrayCrescente);
		System.out.print("Array ordenado decrescentemente: ");
		escreveArray(arrayDecrescente);		
	}
	
	public static int[] ordenaCrescente(int crescente[]) {
		int aux = 0;
		for (int x = 0; x < crescente.length-1; x++) {
			for (int y = 0; y < crescente.length-1; y++) {
				if (crescente[y] > crescente[y + 1]) {
					aux = crescente[y];
					crescente[y] = crescente[y + 1];
					crescente[y + 1] = aux;
				}
			}
		}  
		return crescente;
	}
	
	public static int[] ordenaDecrescente(int decrescente[]) {
		int aux = 0;
		for (int x = 0; x < decrescente.length-1; x++) {
			for (int y = 0; y < decrescente.length-1; y++) {
				if (decrescente[y] < decrescente[y + 1]) {
					aux = decrescente[y];
					decrescente[y] = decrescente[y + 1];
					decrescente[y + 1] = aux;
				}
			}
		}  
		return decrescente;
	}
	
	public static void escreveArray(int[] array) {
		for (int j = 0; j < array.length; j++) {
			System.out.print(array[j]+" ");
		}
		System.out.print("\n");
	}
	
}

A cada método que chamo (métodos de ordenção) o outro array é substituído. Ou seja, quando chamo o método escreveArray, escreve sempre a mesma coisa. Por quê?

Voce nao pode usar o proprio metodo de ordenação da classe Arrays?

Não rola pq professor da facul quer desse jeito…

Sendo assim eu faria uma lógica diferente…

Eu percorreria o array pegaria o menor valor e colocaria em outro e retiraria do primeiro… depois pegasse o menor denovo(que vai se ro segundo menor já que foi tirado o primeiro) e colocaria no outro array assim sucessivamente até acabar.

E para descrecente começaria pelo maior e iria fazendo o mesmo.

Mas deve ter outro modo de fazer isso.

Dê uma olhada no código da java.util.Arrays.

O problema é o seguinte…
O professor pediu pra criar métodos que ornenascem de forma crescente e decrescente… Até tranquiloo, os dois métodos que criei funcionam perfeitamente… Os métodos retornam o array ordenado e eu jogo esse retorno em outro array, já que preciso escrever os arrays ordenados e o não ordenado. O problema é que cada vez que chamo um método ele ta substituindo o valor da variável. Exemplo:

 int arrayDecrescente[] = ordenaDecrescente(arrayNoraml);  
 int arrayCrescente[] = ordenaCrescente(arrayNoraml);  

Quando eu chamo o ordenaCrescente() o valor do arrayDrecrescente[] tá ficando com o retorno do método.
Assim quando eu mando escrever os arrays eles estão sempre com o valor do último método que eu chamei.

Ahhh…

crie uma cópia do array antes de trabalhar com ele.

public static int[] ordenaCrescente(int cresc[]) {  
         int[] crescente = (int[]) cresc.clone();
         int aux = 0;  
         for (int x = 0; x < crescente.length-1; x++) {  
             for (int y = 0; y < crescente.length-1; y++) {  
                 if (crescente[y] > crescente[y + 1]) {  
                     aux = crescente[y];  
                     crescente[y] = crescente[y + 1];  
                     crescente[y + 1] = aux;  
                 }  
             }  
         }    
         return crescente;  
     }

 public static int[] ordenaDecrescente(int decr[]) {  
         int decrescente[] = (int[]) decr.clone();
         int aux = 0;  
         for (int x = 0; x < decrescente.length-1; x++) {  
             for (int y = 0; y < decrescente.length-1; y++) {  
                 if (decrescente[y] < decrescente[y + 1]) {  
                     aux = decrescente[y];  
                     decrescente[y] = decrescente[y + 1];  
                     decrescente[y + 1] = aux;  
                 }  
             }  
         }    
         return decrescente;  
     }

Perfeito… =)
Agora ta funcinando como esperava…

Muito Obrigado pela força

nao entendo pq esses professores querem reiveintar a roda, ao inves de ta trabalhando outros aspectos da tecnologia, fica forçando reveitar a roda… claro que um exercicio desse ajuda na logica, mas eles podem passar exercicios melhores.

É, pra que esinar álgebra no primário, devíamos passar logos pra teoria das cordas.

é possivel ensinar ordenacao de forma mais eficiente… isso que quis dizer…