如何在Java中使用气泡排序对多维数组进行排序

这是我根据体育运动创建的一个测验，它问了一系列问题，用户每次有3次尝试。从那里，它汇总每个玩家的分数，并以二维数组的形式显示，它比较分数并打印最高分数。如何使用气泡排序（而不是array.sort）按第二个索引（分数）对二维数组（记分板）进行排序

import java.util.*；
小型项目类
{
公共静态void main（字符串[]args）
{
Questions[]Questions=setQuestions（）；//使用setQuestions方法存储问题数组
askQuestion（questions）；//使用questions参数（数组）运行方法askQuestion
}
公共静态问题[]设置问题（）
{
问题[]问题=新问题[4]；//创建类型问题数组
问题A=新问题（）；//创建名为
A.question=“哪个队赢得了1966年的世界杯？”；
A.options=“A.德国\n B.法国\n C.英格兰\n D.威尔士”；
A.answer=“C”；
问题[0]=A；//答案中的第一个问题是A
问题B=新问题（）；
B.question=“谁是当前EPL所有权持有人？”；
B.options=“A.阿森纳\n B.伯恩茅斯\n C.切尔西\n D.曼城”；
B.answer=“D”；
问题[1]=B；
问题C=新问题（）；
C.question=“谁是2017/18赛季的金靴奖得主？”；
C.options=“A.莱昂内尔·梅西\n B.哈里·凯恩\n C.克里斯蒂亚诺·罗纳尔多\n D.戴维森·桑切斯”；
C.answer=“A”；
问题[2]=C；
问题D=新问题（）；
D.question=“哪个团队的目标最多”；
D.options=“A.阿森纳\n B.伯恩茅斯\n C.切尔西\n D.曼城”；
D.answer=“A”；
问题[3]=D；
返回问题；//返回问题数组
}
公共静态void askQuestion（Questions[]数组）
{
int correct=0；
扫描仪sc=新的扫描仪（System.in）；
字符串[][]记分板=新字符串[4][2]；
对于（int m=0；m1；k--）
{
System.out.println（数组[i].问题）；
System.out.println（数组[i].options）；
字符串应答=sc.nextLine（）；
if（answer.equalsIgnoreCase（数组[i].answer））//此循环直到给出正确答案
{
系统输出打印项次（“正确”）；
正确=正确+1；
打破
}
其他的
{
System.out.println（“不正确，您有”+（k-2）+“左尝试”）；
}
}
}  
记分牌[m][1]=整数.toString（正确）；
System.out.println（正确+问题正确）；
}
int mostCorrectIndex=0；
对于（int c=1；cInteger.parseInt（记分板[mostCorrectIndex][1]））
MOST校正指数=c；
} 
System.out.println（“得分最高的人是”+记分板[mostCorrectIndex][0]）；
对于（int b=0；b

如果我理解正确，您的2d数组结构如下：

{name,score}
{name,score}
{name,score}
{name,score}

Player[] scoreboard = new Player[playerSize];

您需要根据第二列对数据进行排序：score

与其在2D数组中实现它，不如创建一个名为Player的对象

如果玩家有一个实现：

public class Player{

    private String name;
    private int score;        

    Player(String name){
        this.name = name;
    }

    public void setScore(int score){
        this.score = score;
    }

    public int getScore(){
        return score;
    }
}

现在，您的记分板可以实现为一维数组，如下所示：

{name,score}
{name,score}
{name,score}
{name,score}

Player[] scoreboard = new Player[playerSize];

更容易理解和阅读

现在，为了对这个数组进行排序，您可以实现一个自定义类，它允许您比较两个类型为Player的对象

class comparePlayer implements Comparator<Player>{

    public int compare(Player a, Player b) {
        if (a.getScore() < b.getScore()){
            return -1;
        }
        else if (a.getScore() == b.getScore()){
            return 0;
        }
        else{
            return 1;
        }
    }

}

或者，如果您真的想使用冒泡排序，则可以这样实现：

int length = scoreboard.length; 
for (int i = 0; i < length-1; i++){ 
    for (int j = 0; j < length-i-1; j++){ 
        if (scoreboard[j].getScore() > scoreboard[j+1].getScore()){ 
            Player temp = scoreboard[j]; 
            scoreboard[j] = scoreboard[j+1]; 
            scoreboard[j+1] = temp; 
        } 
    }
}

int length=scoreboard.length；
对于（int i=0；i记分板[j+1].getScore（））{
球员温度=记分牌[j]；
记分牌[j]=记分牌[j+1]；
记分牌[j+1]=临时；
} 
}
}

在此上下文中，您可以通过修改实现冒泡排序，以比较重要的值。例如：

static void bubbleSort(String[][] arr) {
        int arrayLength = arr.length;
        for (int i = 0; i < arrayLength; i++) {
            for (int j = 1; j < (arrayLength - i); j++) {
                String nameTemp, scoreTemp;
                int leftValue, rightValue;
                leftValue = Integer.valueOf(arr[j - 1][1]);
                rightValue = Integer.valueOf(arr[j][1]);
                if (leftValue > rightValue) {
                    //swap elements
                    nameTemp = arr[j - 1][0];
                    scoreTemp = arr[j - 1][1];
                    arr[j - 1][0] = arr[j][0];
                    arr[j - 1][1] = arr[j][1];
                    arr[j][0] = nameTemp;
                    arr[j][1] = scoreTemp;
                }

            }
        }
}

静态void bubbleSort（字符串[][]arr）{
int arrayLength=阵列长度；
对于（int i=0；irightValue）{
//交换元素
nameTemp=arr[j-1][0]；
scoreTemp=arr[j-1][1]；
arr[j-1][0]=arr[j][0]；
arr[j-1][1]=arr[j][1]；
arr[j][0]=名称温度；
arr[j][1]=记分温度；
}
}
}
}

---

然后，您需要数组的最后一个索引，因为它是按升序排序的。

我不明白

String[][]记分板

代表什么。此数组中包含哪些值以及它们的含义是什么？用户的名称位于索引0上。他们得到的分数在指数1上。