Question

这是我在网站上的第一个问题。我在一个CS类中，我的一个任务的一部分涉及将数组的得分列从最小到最大排序，并以最小到最大的形式打印出数组。无论出于何种原因，我似乎无法从阵列中得到分数，而且我很困惑为什么它不起作用。如果你们中的任何人能帮助我，那就太棒了。谢谢！这是我正在使用的数组。两列是id（在左侧）和得分（在右侧）：

到目前为止，这是我的代码：

import java.io.*;
import java.util.*;
public class RankingTestScoresDriver
{
public static void main(String args[])
{
    System.out.println("ID     Score");
    File file = new File("prog408a.dat");
    int[] id = new int[24];
    int[] score = new int[24];
    try
    {
        Scanner kbReader = new Scanner(file);
        while (kbReader.hasNextInt())
        {
            for (int i = 0; i < 25; i++)
            {
                id[i] = kbReader.nextInt();
                score[i] = kbReader.nextInt();
            }
        }
    }
    catch (Exception e)
    {

    }

//From here down is the part which is giving me trouble.

    int max;
    max = score[0];
    int index;
    int maxScoreIndex = 0;
    for (int k = 0; k < 25; k++)
    {
    for (index = 0; index < score.length; index++)
    {
        if (score[index] > max)
        {
            max = score[index];
            maxScoreIndex = index;
        }
    }
    System.out.println(maxScoreIndex + "     " + max);
    score[maxScoreIndex] = ((-1)*(max));
    }
}

}

目前正在制作此产品：

ID分数 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599 12 599

最终输出应该是数组的得分，但是从最小到最大的顺序。

在帮助我修复我正在努力解决的一些代码时，将非常感谢任何帮助。

Answer 1

您可以编写一个实现Comparable的类来简化它。

class Score implements Comparable<Score> {
    private int id, score;
    Score(int id, int score) {
        this.id = id;
        this.score = score;
    }

    @override
    public int compareTo(Score o) {
        return score - o.score;
    }
}

然后在创建Score数组后，您可以使用sort()方法。

Score[] scores = /* put data */
Arrays.sort(scores);

将起作用

Answer 2

在您尝试排序的部分中，我建议您在阵列上调用Arrays.sort（），如下所示：

Arrays.sort(score);

对阵列进行排序后，使用某种循环从头开始打印出每个元素：

for(int i = 0; i < 25; i++)
{
    System.out.println(i + "     " + score[i]);
}

那应该为你做的伎俩。如果您不需要花哨的新排序算法，只需使用已为您编码的算法：）

Answer 3

您需要对数组进行排序。现在你的代码没有这样做，只是跟踪最大的价值。

我假设您不必担心执行时间。换句话说，如果算法需要很长时间才能执行大输入，那么对你的教授来说无关紧要。

有很多方法可以对数组进行排序。一种方法称为Bubble Sort。它不是很有效，但会为你做到这一点，这可能是你教授现在想要的。

这个想法非常简单：您发现整个阵列上的最低值，并将值与当前位置交换。想象一下，你有以下数组：

[2,4,3,5,1]

您当前的索引是0。你将通过整个数组来找到它们的最低值。您将发现保存值1的索引4包含最低值。因此，您交换当前索引（索引0，值2）。现在数组看起来像这样：

[1,4,3,5,2]

现在转到下一个索引1。您不再需要查看索引0，因为您已经发现他是最低值，现在您想要第二个最低值。你做同样的事情：找到从索引1到索引4的最低值并交换它们。你要做到这一点，直到你到达最后一个索引，你可以猜到，它总是最大的值。

首先确保您获得第一个正确的值。一旦你得到它，然后移动到迭代其他值的循环。

Answer 4

工作代码：对java中的列值排序二维数组。

这里我们在java.util.Arrays类中使用重载排序方法，它使用两个参数： 数组进行排序 和 java.util.Comparator对象 。

import java.util.Arrays;
import java.util.Comparator;

public class SortArray {

    Integer array[][] = { { 365, 265 }, { 222, 223 }, { 306, 262 },
            { 003, 559 }, { 004, 560 }, { 203, 224 }, { 113, 243 },
            { 208, 242 }, { 213, 229 }, { 115, 257 }, { 302, 242 },
            { 223, 230 }, { 001, 599 }, { 311, 256 }, { 323, 245 },
            { 321, 245 }, { 123, 253 }, { 104, 239 }, { 002, 513 },
            { 112, 239 }, { 207, 228 }, { 325, 246 }, { 116, 246 },
            { 218, 243 }, { 110, 238 } };

    SortArray() {
        System.out.println("Before sorting");
        // show the contents of array
        displayArray();

        // sort array on score(second column)
        Arrays.sort(array, new Comparator<Integer[]>() {
            @Override
            public int compare(Integer[] o1, Integer[] o2) {
                Integer v1 = o1[1];
                Integer v2 = o2[1];
                // reverse sort on quantity
                return v1.compareTo(v2);
            }
        });
        // display array after sort
        System.out.println("After sorting on score in ascending order");
        displayArray();

    }

    public void displayArray() {

        System.out.println("-------------------------------------");
        System.out.println(" Index \t\t score");
        for (int i = 0; i < array.length; i++) {
            Integer[] sorted = array[i];
            System.out.println(sorted[0] + "\t\t" + sorted[1]);
        }
        System.out.println("-------------------------------------");
    }

    public static void main(String[] args) {
        new SortArray();
    }

}

<强>解释

创建一个名为array的二维数组，并使用默认值进行初始化。数组的第一列由索引值组成，第二列是其得分。为了对数组进行排序，使用了java.util.Arrays的sort方法，该方法有两个参数：要排序的数组和一个java.util.Comparator对象。

我们传递一个匿名的Comparator对象（匿名对象表示一个没有名称且仅在其使用地点创建的对象）。由于java中的2d数组是一个数组数组，因此，为了对列上的2d数组进行排序，我们必须对整数数组进行排序，因此该Comparator对象的泛型类型应为Integer []。

在Comparator对象中，我们实现了compare方法，该方法接受两个Integer []类型的对象。这些Integer对象表示要比较的数组。为了在第二列（得分）上对数组进行排序，检索并比较Integer []对象的索引1处的值。

另请阅读Comparators和sort()

public static <T> void sort(T[] a,
            Comparator<? super T> c)

根据指定比较器引发的顺序对指定的对象数组进行排序。数组中的所有元素必须通过指定的比较器相互比较（即，c.compare（e1，e2）不得为数组中的任何元素e1和e2抛出ClassCastException）。这种类型保证是稳定的：相同的元素不会因排序而重新排序。

实现注意事项：此实现是一个稳定的，自适应的迭代合并输出，当输入数组被部分排序时，需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统mergesort的性能。如果输入数组几乎已排序，则实现需要大约n次比较。临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。

该实现在其输入数组中具有升序和降序的相同优势，并且可以利用相同输入数组的不同部分中的升序和降序。它非常适合合并两个或多个排序数组：只需连接数组并对结果数组进行排序。

该实现改编自Tim Peters的Python排序（TimSort）。它使用了Peter McIlroy的“乐观排序和信息理论复杂性”中的技术，参见“第四届年度ACM-SIAM离散算法研讨会论文集”，第467-474页，1993年1月。

参数： a - 要排序的数组 c - 用于确定阵列顺序的比较器。空值表示应该使用元素的自然顺序。

Java：将数组从最小到最大排序

4 个答案: