降低生成秩数组的时间复杂度

Question

public Ranking(String[] names, float[] scores) { nameTest = 新城市[names.length]; rankTest = 新城市[names.length]; 城市 = 新城市 [names.length]; scoreRanks = new Float[scores.length]; for (int i = 0; i

        for (int p = 0; p < scoreRanks.length; p++) {
            scoreRanks[p] = scores[p];
        }
        int[] ranking = new int[names.length];
        for (int k = 0; k < ranking.length; k++) {
            ranking[this.smallestIndex()] = k + 1;
        }
        for (int i = 0; i < ranking.length; i++) {
            city[i] = new Cities(names[i], ranking[i]);
            nameTest[i] = new Cities(names[i], ranking[i]);
            rankTest[i] = new Cities(names[i], ranking[i]);
        }
        Arrays.sort(nameTest, Cities.BY_NAME);
        Arrays.sort(rankTest, Cities.BY_RANK);
        for (int i = 0; i < names.length - 1; i++) {
            if (nameTest[i].getName().equals(nameTest[i + 1].getName())
                    || nameTest[i].getName() == null
                    || rankTest[i].getRank() == rankTest[i + 1].getRank())
                throw new IllegalArgumentException();
        }
    }

    public int smallestIndex() {
        float smallest = 0.0f;
        int i;
        for (i = 0; i < scoreRanks.length; i++) {
            if (scoreRanks[i] > 0.0f) {
                smallest = scoreRanks[i];
                break;
            } else
                continue;
        }
        int j = 1;
        while (j < scoreRanks.length) {
            if (scoreRanks[j] < smallest && scoreRanks[j] != 0.0f) {
                smallest = scoreRanks[j];
                i = j;
            }
            j++;
        }
        scoreRanks[i] = 0.0f;
        return i;
    }

这是我的排名构造函数。目前，在 for 循环中对 minimumIndex() 的调用将其提高到 O(n^2) 时间，但我需要它在不超过 O(n log n) 时间内运行。

它的作用是获取一组分数和名称。然后得分最低的位置将是排名 1，次低的位置是排名 2，依此类推。然后我可以创建 Cities 对象，其中 names[i] 对应于ranking[i]。

希望这是有道理的。买是的，但在 O(n log n) 时间内，我无法获得相同的结果。我的代码完美运行，我猜它太慢了:(。

另外，O(2n log n + 5n) 会归结为 O(n log n) 吗？

Answer 1

根据您的描述，基本上您希望根据分数的增加对列表进行排序。检查smallestIndex 中的代码，您似乎确实在以一种非常低效的方式执行此操作。如果我们要保留该方法，我建议将scoreRanks[i] = 0.0f 更改为scoreRanks[i] = Float.MAX_VALUE 并通过循环一次来简化方法。

但为了有效地完成任务，我建议完全删除 smallestIndex。我看到您已经在使用 Arrays.sort 和自定义比较器。只需使用相同的方法，您就可以有效地解决您的任务。您可以按照此问题中的说明创建自定义比较器：Get the indices of an array after sorting?

class ArrayIndexComparator implements Comparator<Integer>
{
    private Float[] scores;

    public ArrayIndexComparator(float[] scores)
    {
        this.scores = new Float[scores.length];
        for(int i=0; i<scores.length; i++){
            this.scores[i] = scores[i];
        }
    }

    public Integer[] createIndexArray()
    {
        Integer[] indexes = new Integer[scores.length];
        for (int i = 0; i < scores.length; i++)
        {
            indexes[i] = i;
        }
        return indexes;
    }

    @Override
    public int compare(Integer index1, Integer index2)
    {
        // Autounbox from Integer to int to use as array indexes
        return scores[index1].compareTo(scores[index2]);
    }

    public static void main(String[] args){
        float[] scoreRanks = new float[]{2.0f,3.0f,1.0f};
        ArrayIndexComparator comparator = new ArrayIndexComparator(scoreRanks);
        Integer[] indexes = comparator.createIndexArray();
        Arrays.sort(indexes, comparator);
        int[] ranking = new int[indexes.length];
        for (int i = 0; i < ranking.length; i++) {
            ranking[indexes[i]] = i + 1;
        }
        for (int i = 0; i < ranking.length; i++){
            System.out.println(ranking[i]+" "+scoreRanks[i]);
        }
        // Will print:
        // 2.0 2
        // 3.0 3
        // 1.0 1
    }
}

public Ranking(String[] names, float[] scores) {
    nameTest = new Cities[names.length];
    rankTest = new Cities[names.length];
    city = new Cities[names.length];
    scoreRanks = new Float[scores.length];
    for (int i = 0; i < scores.length - 1; i++) {
        if (scores[i] == scores[i + 1])
            throw new IllegalArgumentException();
    }
    if (names == null || scores == null)
        throw new NullPointerException();
    if (names.length != scores.length)
        throw new IllegalArgumentException();
    for (int p = 0; p < scoreRanks.length; p++) {
        scoreRanks[p] = scores[p];
    }
    // This is the updated part
    ArrayIndexComparator comparator = new ArrayIndexComparator(scoreRanks);
    Integer[] indexes = comparator.createIndexArray();
    Arrays.sort(indexes, comparator);
    int[] ranking = new int[indexes.length];
    for (int i = 0; i < ranking.length; i++) {
        ranking[indexes[i]] = i + 1;
    }
    // Up until this part
    for (int i = 0; i < ranking.length; i++) {
        city[i] = new Cities(names[i], ranking[i]);
        nameTest[i] = new Cities(names[i], ranking[i]);
        rankTest[i] = new Cities(names[i], ranking[i]);
    }
    Arrays.sort(nameTest, Cities.BY_NAME);
    Arrays.sort(rankTest, Cities.BY_RANK);
    for (int i = 0; i < names.length - 1; i++) {
        if (nameTest[i].getName().equals(nameTest[i + 1].getName())
                || nameTest[i].getName() == null
                || rankTest[i].getRank() == rankTest[i + 1].getRank())
            throw new IllegalArgumentException();
    }
}

这样你将使用Arrays类中的排序方法，即O(n log n)。