ordenar matriz

[~H~]

Bueno me gustaría saber si alguien sabe hacer este programa de una manera más rápida, es decir un algoritmo que la ordene sin tener que pasarlo a monodimensional y luego volver a meter los elementos en la matriz.
Me refiero al método ordenaMatriz, porque el otro creo que está bien, el programa funciona, pero creo que no es la forma adecuada de hacerlo.

Gracias de antemano

Código [Seleccionar] Expandir

import java.util.Scanner;

public class ordenar {
public static int [] ordenarVector (int n[]){
int aux = 0;
int ordenado [] = new int [n.length];
for(int i = 0; i < n.length - 1; i++){
for(int k = i + 1; k < n.length; k++){
if(n[k] < n[i]){
aux = n[i];
n[i] = n[k];
n[k] = aux;
}
}
}
return ordenado;
}
public static int [][] ordenarMatriz (int n[][]){

int vectorAux [] = new int [n.length * n[0].length];
int contAux = 0;

/*Rellenamos el vector auxiliar con los elementos
*de la matriz para poder ordenarlo.
*/
for(int k = 0; k < n.length; k++){
for(int l = 0; l < n[k].length; l++){
vectorAux[contAux] = n[k][l];
contAux++;
}
}

int aux = 0;
for(int i = 0; i < vectorAux.length - 1; i++){
for(int j = i + 1; j < vectorAux.length; j++){
if(vectorAux[j] < vectorAux[i]){
aux = vectorAux[i];
vectorAux[i] = vectorAux[j];
vectorAux[j] = aux;
}
}
}
//Ponemos los valores ordenados de nuevo en la matriz.
int cont = 0;
for(int k = 0; k < n.length; k++){
for(int l = 0; l < n[k].length; l++){
n[k][l] = vectorAux[cont];
cont++;
}
}
return n;
}
public static void mostrarVector(int array[]){
for(int i = 0; i < array.length; i++){
System.out.print(array[i]);
}
System.out.println();
}
public static void pedirElementos(int array []){
Scanner leer = new Scanner(System.in);
for(int i = 0; i < array.length; i++){
System.out.print("Elemento ["+i+"]:" );
array [i] = leer.nextInt();
}
}
public static void pedirElementosBi(int array [][]){
Scanner leer = new Scanner(System.in);
for(int i = 0; i < array.length; i++){
for(int j = 0; j < array[i].length;j++){
System.out.print("Elemento ["+i+j+"]:" );
array [i][j] = leer.nextInt();
}
}
}
public static void mostrarMatriz(int array [][]){
for(int i = 0; i < array.length; i++){
for(int j = 0; j < array[i].length;j++){
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
public static void main(String [] args){
Scanner leer = new Scanner (System.in);
System.out.println("Ordenar arrays");
System.out.println("1-monodimensional");
System.out.println("2-bidimensional");
int x = leer.nextInt();
switch(x){
case 1:
System.out.println("Longuitud del vector");
int n = leer.nextInt();
int vector [] = new int [n];
pedirElementos(vector);
System.out.println();
mostrarVector(vector);
int [] ordenado = ordenarVector(vector);
mostrarVector(ordenado);

break;
case 2:
System.out.println("Filas");
int nF = leer.nextInt();
System.out.println("Columnas");
int nC = leer.nextInt();
int matriz [][] = new int [nF][nC];
pedirElementosBi(matriz);
System.out.println();
int [][] matrizOrdenada = ordenarMatriz(matriz);
mostrarMatriz(matrizOrdenada);
break;

default:
System.out.println("Un 1 o un 2 imbécil");
}
}
}


[egyware]

Solo al ver tu problema, se me ocurrieron muchas maneras de resolverlo.

Aunque lo primero que haría es demostrar cuando se demora tu problema en general. Si es que aún tienes intenciones de encontrar una manera más eficiente.

Dada una matriz m y n dimensiones y l el largo del vector donde l = m*n.

• Pasar matriz a vector tiene un costo de O(m*n)
• Ordenar vector tiene un costo O(l^2) (me da la impresión que usas burbuja, por el ciclo for anidado)
• Pasar el vector a matriz tiene un costo de O(m*n)

En total, tu algoritmo tiene un costo de...  2 * O(m*n) + O((m*n)^2) osea O((m*n)^2)
Por lo que podemos apreciar lo más costoso, es ordenar el arreglo. Podrías usar Quicksort para hacerlo más eficiente.

Bueno con esto podrías empezar a buscar métodos más eficientes para tu algoritmo.

Saludos!