在java中使用BUBBLE SORT对二维字符串数组进行排序

Question

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

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

您可以将第一个索引视为行索引，将第二个索引视为列索引。比如下面的Java数组和表是相互对应的：

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

-

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

继续这个例子，table[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;
                    }
                }
            }
        }
    }

我收到一个 Index out of Bounds 错误，而且它也无法正常工作，因为测试期望 table[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

我的工作解决方案：

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

给你的一些注意事项：

1. 使用有意义的名称（rows 比 table.length 更容易理解）
2. 冒泡排序循环有点不对劲，网上有很多例子说明如何进行
3. 如前所述，您应该从一维数组开始，然后“概括”它
4. 您遇到的一个大问题：使用 j（应该是要比较的行的索引）作为列（并忽略列）
5. 另一个大问题是只替换元素（而不是行）

希望对你有帮助！

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

Answer 4

首先，将其设为一维数组 或至少 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