Ordenando 2D Array cadena con BubbleSort en Java

Pablo Biedma :

Preguntas similares se les ha pedido, pero nunca acerca de cuerda matrices 2D, por lo tanto, después de intentarlo durante mucho tiempo no pude encontrar lo que quería. Estoy tratando de ordenar una matriz 2D de cadena en Java utilizando BubbleSort.

Como entrada, recibo una matriz de dos dimensiones (una mesa) de Cuerdas y el índice de la “columna” que debe ordenar. Debería ordenar las filas de los valores en la columna indicada.

Se puede ver el primer índice como un índice de la fila, y el segundo índice como un índice de la columna. Por ejemplo, la siguiente matriz Java y corresponden mesa entre sí:

String[][] table = {
  {"a", "b"},
  {"c", "d"}
};

-

0   1
  +---+---+
0 | a | b |
  +---+---+
1 | c | d |
  +---+---+

Para continuar en este ejemplo, la tabla [0] [1] producirá el valor "b", ya que es el elemento en la fila 0 y la columna 1.

IMPORTANTE: No se me permite utilizar cualquier algoritmo de ordenación de la biblioteca de Java, por ejemplo Arrays.sort.

Esto es lo que he probado hasta ahora:

class Solution {
        public static void stableSort(String[][] table, int column) {
            int i;
            int j;
            String temp = null;
            for (i = 0; i < table.length - 1; i++) {
                for (j = 0; j < table.length - 1 - i; j++) {
                    if (table[i][j].compareTo(table[i][j + 1]) > 0) {
                        temp = table[i][j];
                        table[i][j] = table[i][j + 1];
                        table[i][j + 1] = temp;
                    }
                }
            }
        }
    }

Me aparece un índice fuera de los límites de error y también que no está funcionando como se espera que la prueba de un resultado diferente en la tabla [0] [0] Gracias por su ayuda.

Roy Shahaf:

Mi solución de trabajo:

import java.util.Arrays;

public class MySolution {
    public static void stableSort(String[][] table, int column) {
        String[] temp = null;
        int rows = table.length;
        for (int i = 0; i < rows; i++) {
            for (int j = 1; j < (rows - i); j++) {
                if (table[j - 1][column].compareTo(table[j][column]) > 0) {
                    temp = table[j - 1];
                    table[j - 1] = table[j];
                    table[j] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        String[][] table = { { "c", "d" }, { "a", "b" } };
        printTable(table);
        stableSort(table, 1);
        printTable(table);
    }

    private static void printTable(String[][] table) {
        System.out.println("table:");
        for (int i = 0; i < table.length; i++) {
            System.out.println(Arrays.toString(table[i]));
        }
    }
}

algunas notas para usted:

1. usar nombres significativos (filas es fácil de entender que table.length)
2. bucles de burbujas ordenar eran un poco apagado, hay un montón de ejemplos de cómo hacerlo en línea
3. como se ha mencionado, usted debe comenzar por hacerlo por matriz 1d y luego "generalizar" se
4. Un gran problema que tenía: el uso de j (que debe ser el índice de la fila de comparar a) que la columna (y haciendo caso omiso de la columna)
5. otro gran problema sólo se está sustituyendo el elemento (en lugar de las filas)

¡Espero que esto te ayude!

EDIT: Me he dado cuenta de que también haya cambiado entre la fila y columna en el código (en su explicación el primer índice indica la fila, en el código que parece que lo contrario es correcto)