对 ArrayList 进行排序，但保持原始索引的顺序

Question

有两个 int 数组和一个名为 cost 和 shipping 的数组列表。我想要一个总价从最低到最高的 ArrayList（例如 cost[0] + shipping[0]），但重新排序两个 int 数组以匹配 ArrayList：

Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] costs = new int[n];
int[] shipping = new int[n];
ArrayList<Integer> totalCosts = new ArrayList<>();

例如，假设成本为 [1, 5, 2, 3]，运费为 [2, 3, 2, 4]，那么 totalCosts 将是 {3, 8, 4, 7} 并排序为{3、4、7、8}。我希望重新排序费用和运费，以便它们与总数相对应，因此费用为 [1, 2, 3, 5]，运费为 [2, 2, 4, 3]。

Answer 1

public List<Integer> sortPrices(int[] cost, int[] shipping) {
    List<Integer> result = new ArrayList<>();
    TreeMap<Integer, List<int[]>> map = new TreeMap<>();
    int length = cost.length;
    int[] origCost = new int[length];
    int[] origShipping = new int[length];
    for (int i = 0; i < length; i++) {
        int price = cost[i] + shipping[i];
        int[] arr = {i, i};
        map.putIfAbsent(price, new ArrayList<>());
        map.get(price).add(arr);
        origCost[i] = cost[i];
        origShipping[i] = shipping[i];
    }
    int j = 0;
    for (int price : map.keySet()) {
        for (int[] arr : map.get(price)) {
            int ci = arr[0];
            int si = arr[1];
            cost[j] = origCost[ci];
            shipping[j] = origShipping[si];
            j++;
            result.add(price);
        }
    }
    return result;
}

Answer 2

我用python解决了

只要了解循环逻辑，你就可以做到。

for i in range(len(total)):
  for j in range(len(total)):
    if sorted_total[i]==total[j]:
        new_costs[i]=costs[j]
        new_shipping[i]=shipping[j]
        print("i ",i)
        print("j ",j)
        break

Answer 3

这是一个不使用地图的解决方案。相反，我们有一个自定义比较器，它使用成本和运费的总和来对数组位置进行排序。然后我们创建新数组并从旧数组中的排序位置中选择值。

public static void main(String[] args) {
    int n = 4;
    int[] costs = {1, 5, 2, 3};
    int[] shipping = {2, 3, 2, 4};
    Integer[] totals = new Integer[n];
    for(int i = 0; i < n; ++i) {
        totals[i] = i;
    }

    Arrays.sort(totals, Comparator.comparingInt(k -> (costs[k] + shipping[k])));

    int[] newCosts = new int[n];
    int[] newShipping = new int[n];
    for(int i = 0; i < n; ++i) {
        newCosts[i] = costs[totals[i]];
        newShipping[i] = shipping[totals[i]];
    }

    for(int i = 0; i < n; ++i){
        System.out.println((i + 1) + ": Cost=" + newCosts[i] + ", Shipping=" + newShipping[i] + ", Total=" + (newCosts[i] + newShipping[i]));
    }
}

说明

totals 数组包含从 0 到 n（示例中为 4）的索引列表。 Arrays.sort() 使用 Comparator 对索引进行排序，给定索引，提取该位置的总数。 totals 数组在排序后将按顺序列出成本和运费总和的索引。

之后，我们可以使用排序索引创建新的成本和运费数组。

编辑

听从 ttzn 的 cmets 建议，你可以把代码压缩成这样：

public static void main(String[] args) {
    int n = 4;
    int[] costs = {1, 5, 2, 3};
    int[] shipping = {2, 3, 2, 4};

    int[] totals = IntStream.range(0, n).boxed().sorted(Comparator.comparingInt(k -> (costs[(int)k] + shipping[(int)k]))).mapToInt(Integer::intValue).toArray();

    int[] newCosts = IntStream.of(totals).map(i -> costs[i]).toArray();
    int[] newShipping = IntStream.of(totals).map(i -> shipping[i]).toArray();

    for (int i = 0; i < n; ++i) {
        System.out.println((i + 1) + ": Cost=" + newCosts[i] + ", Shipping=" + newShipping[i] + ", Total=" + (newCosts[i] + newShipping[i]));
    }
}

Answer 4

这是一个基于流的解决方案，无需构建地图。

1. 构建了一个Stream<int[]>，将总数和索引存储在int[]数组中，

2. 使用这些数组的自定义比较器对流进行排序（首先按总数，然后按索引）

3. 故意将peek 与AtomicInteger 一起使用以重新排序输入costs 和ships 数组
   注意：但是，这可能会被视为一种“滥用”并加重- 数据流外部的效果更新

4. 构建并返回总计数组。

public static int[] getTotals(int[] costs, int[] ships) {
    assert costs.length == ships.length;
    int[] copyCosts = Arrays.copyOf(costs, costs.length);
    int[] copyShips = Arrays.copyOf(ships, ships.length);
    
    AtomicInteger ix = new AtomicInteger(0);
    
    return IntStream.range(0, costs.length)
                    .mapToObj(i -> new int[]{ costs[i] + ships[i], i })
                    .sorted(Comparator.<int[]>
                        comparingInt(p -> p[0])
                        .thenComparingInt(p -> p[1])
                    ) // get sorted Stream<int[]>
                    .peek(p -> {
                        costs[ix.get()] = copyCosts[p[1]];
                        ships[ix.getAndIncrement()] = copyShips[p[1]];
                    })
                    .mapToInt(p -> p[0])
                    .toArray();
}