根據基於兩個數組的值對數組進行排序

Question

我目前有 2 個陣列，功率和能量：

int[] power = [20, 10, 50, 10, 30, 5];
powerIndex     0   1   2   3   4   5
int[] energy = [20, 5, 15, 3, 10, 30];
energyIndex    0   1   2   3   4   5

我想得到一個排序的功率數組索引的數組（從最低到最高），如果功率數相同，則使用較少能量的功率應該獲得第一名。 所以基本上我想要的輸出是：

int[] result = [5, 3, 1, 0, 4, 2]

到目前為止，這是我的代碼：

        int[] result = new int[power.length];
        int answerIndex = 0;
        int tempSmallest = Integer.MAX_VALUE;
        int lastNumberSaved = 0;
        int posWithSmallerPower = 0;


        while (answerIndex < power.length) {

            for (int i = 0; i < power.length; i++) {
                int current = power[i];
                if (tempSmallest > current && current > lastNumberSaved) {
                    tempSmallest = current;
                    posWithSmallerPower = i;
                }

                if (tempSmallest >= current && current > lastNumberSaved) {
                    if (current != lastNumberSaved && energy[posWithSmallerPower] > energy[i]) {
                        tempSmallest = current;
                        posWithSmallerPower = i;
                    }
                }
            }
            answer[answerIndex] = posWithSmallerPower;
            answerIndex++;
            lastNumberSaved = tempSmallest;
            tempSmallest = Integer.MAX_VALUE;
        }

        return answer;

我得到了什么：[5, 3, 0, 4, 2, 2]。 再一次，我應該得到什么：[5, 3, 1, 0, 4, 2]

我在處理具有相同數字的權力時遇到了麻煩。 我確實通過它們的能量在第二個數組中比較了它們，實際上我首先獲得了索引 3 中的冪，但隨后代碼完全忘記了同樣具有相同數字 (10) 的第二次冪。

我如何實現這一目標？ 謝謝！

Answer 1

對於實現Comparable接口的臨時數據結構來說，這似乎是一個很好的用例。 Comparable的javadoc解釋了它是如何工作得很好，但這是一個例子：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public final class Main {

    private static class Entry implements Comparable<Entry> {
        private final int power;
        private final int energy;
        private final int index;

        public Entry(int power, int energy, int index) {
            this.power = power;
            this.energy = energy;
            this.index = index;
        }

        @Override
        public int compareTo(Entry o) {
            if (this.power != o.power) {
                return this.power - o.power;
            }
            return this.energy - o.energy;
        }
    }

    public static void main(String[] args) {
        int[] power = {20, 10, 50, 10, 30, 5};
        int[] energy = {20, 5, 15, 3, 10, 30};

        List<Entry> entries = new ArrayList<>();
        for (int i = 0; i < power.length; i++) {
            entries.add(new Entry(power[i], energy[i], i));
        }

        Collections.sort(entries);
        List<Integer> result = entries.stream()
                .map(entry -> entry.index)
                .collect(Collectors.toList());
        System.out.println(result);
    }
}

哪些輸出：

[5, 3, 1, 0, 4, 2]

Answer 2

在list.sort()使用內聯Comparator<T>來比較兩個 powerEnergyIndex。

import java.util.ArrayList;
import java.util.List;

public class MainApplication {
    public static void main(String[] args) {
        int[] power = {20, 10, 50, 10, 30, 5};

        int[] energy = {20, 5, 15, 3, 10, 30};

        List<PowerEnergyIndex> powerEnergyIndices = new ArrayList<>();

        for(int i=0;i<power.length;i++) {
            powerEnergyIndices.add(new PowerEnergyIndex(power[i],energy[i],i));
        }

        powerEnergyIndices.sort((p1, p2)-> {
            if(p1.power!=p2.power) {
                return p1.power-p2.power;
            }
            return p1.energy-p2.energy;
        });

        int[] result = powerEnergyIndices.stream()
                                            .map(powerEnergyIndex -> powerEnergyIndex.index)
                                            .mapToInt(x->x)
                                            .toArray();

        for(int i:result) {
            System.out.print(i + " ");
        }



    }

    static class PowerEnergyIndex {
        private int power;
        private int energy;
        private int index;

        public PowerEnergyIndex(final int power, final int energy, final int index) {
            this.power = power;
            this.energy = energy;
            this.index = index;
        }
    }
}

輸出5 3 1 0 4 2