Question

有人问过类似的问题，但从来没有问过关于2D字符串数组的问题，因此尝试了很长时间后，我找不到我想要的东西。我正在尝试使用BubbleSort在Java中对2D字符串数组进行排序。

作为输入，我收到一个字符串的二维数组（一个表）和应该排序的“列”的索引。我应该按指定列中的值对行进行排序。

您可以将第一个索引视为行索引，将第二个索引视为列索引。例如，以下Java数组和表彼此对应：

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

-

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

在本示例中，表[0] [1]将产生值“ b”，因为它是第0行和第1列中的项目。

重要提示：不允许我使用Java库中的任何排序算法，例如Arrays.sort。

这是我到目前为止尝试过的：

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;
                    }
                }
            }
        }
    }

我从边界错误中得到了一个索引，并且它也无法正常工作，因为测试期望表[0] [0]中的结果不同感谢您的帮助。

Answer 1

public static String[][] stableSort(String[][] table, int column) {
    int i=0,j=0;
    String[] temp = null;
    boolean swap=true;
    while(swap)
    for (i = 0; i < table.length - 1; i++) {
        swap=false;
        if(table[i][column].compareTo(table[i+1][column]) > 0){
            temp = table[i];
            table[i] = table[i+1];
            table[i+1]=temp;
            swap=true;
        }
    }
    return table;
}

它将继续应用气泡排序，直到不再执行任何交换为止。这时，while（swap）条件不再满足，该方法返回。尝试了一个主要的方法，并且可以正常工作（如果我理解您的意思）：

public static void main(String[] args) {
    String[][] table = {
            {"z", "b", "v"},
            {"s", "w", "a"},
            {"r", "c", "h"}
    };

    table = stableSort(table,1);
    for(int i = 0; i < table.length; i++){
        for(int j = 0; j < table[0].length; j++){
            System.out.printf("%5s ", table[i][j]);
        }
        System.out.println();
    }
}

此输出：

z     b     v 
r     c     h 
s     w     a

Answer 2

编辑：工作且没有错误

如果我进行了精确排序，但是添加了一个if语句来进行行切换，则添加了一个外部循环以将2D数组的长度乘以宽度，然后将for循环控件更改为'<='，那么我得到了跟随

   for(int z = 0; z < table.length * table.length; z++) // exterior for loop to run through the loop multiple times
   {
       for (i = 0; i <= table.length - 1; i++) {
           for (j = 0; j <= table.length - 1; j++) {
              if(j == table.length -1 && i == table.length-1) // If we are at the end then we can continue either to the next iteration or to the end of program
                  continue;
              if(j == table.length -1) // If you are ate the end of the row compare to the next row
              {
                   if (table[i][j].compareTo(table[i+1][0]) > 0) {
                       temp = table[i][j];
                       table[i][j] = table[i+1][0];
                       table[i+1][0] = temp;
                   } 
              }
              else 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;
              }
           }
       }
   }

我看到了您想通过减少放入支票时的支票数

table.length - 1 - i

这对提高效率很有帮助，但首先尝试使排序生效。然后将其修整到更好的瓶坯。

我前面也没有编译器，因此代码可能会出现一些错误

Answer 3

首先将其设为一维数组或至少1d可索引容易得多公式：

x = (int)index/(int)rows
y = index % rows

可以使用1个变量索引并索引一个二维数组这是一个泡泡龙

def sort(self):
    for passnum in range(len(self.array)-1,0,-1):
        for i in range(passnum):
            if self.array[i]>self.array[i+1]:
                temp = self.array[i]
                self.array[i] =  self.array[i+1]
                self.array[i+1] = temp

Answer 4

我的工作解决方案：

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]));
        }
    }
}

为您提供一些注意事项：

使用有意义的名称（行比table.length更容易理解）
气泡排序循环有点差，有很多在线示例的例子
如前所述，您应该先对一维数组进行处理，然后对其进行“一般化”
您遇到的一个大问题：使用j（应该是要比较的行的索引）作为列（并忽略列）
另一个大问题是仅替换元素（而不是行）

希望对您有所帮助！

编辑：我刚刚注意到您也在代码中的行和列之间进行了切换（在您的解释中，第一个索引表示行，在您的代码中，似乎相反是正确的）

在Java

4 个答案: