如何利用两个同长度辅助数组对目标数组实现多级排序？

当然有简洁的实现方案啦！核心思路其实很直观——把三个数组对应位置的元素绑定成一组，按照你要求的优先级排序后，再把目标数组（array3）的元素提取出来就行。

核心逻辑拆解 #

• 第一步：将三个数组的同索引元素打包，确保排序时它们的对应关系不丢失；
• 第二步：定义排序规则：优先按array1的值排序（根据你的示例，是1优先于0，也就是降序），当array1值相同时，再按array2的值降序排序；
• 第三步：从排序后的分组中提取array3的元素，就是最终的目标数组。

Java 实现示例 #

如果用Java 16+，可以用record（一种轻量级数据类）来优雅打包元素：

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

public class LinkedArraySort {
    // 用record打包三个数组的对应元素
    record Element(int arr1Val, int arr2Val, int arr3Val) {}

    public static void main(String[] args) {
        int[] array1 = {0, 1, 1, 1, 0};
        int[] array2 = {5, 3, 4, 2, 0};
        int[] array3 = {0, 1, 2, 3, 4};

        // 打包所有位置的元素
        Element[] elements = new Element[array1.length];
        for (int i = 0; i < array1.length; i++) {
            elements[i] = new Element(array1[i], array2[i], array3[i]);
        }

        // 按规则排序：先array1降序，再array2降序
        Arrays.sort(elements, Comparator.comparingInt(Element::arr1Val).reversed()
                .thenComparingInt(Element::arr2Val).reversed());

        // 提取排序后的array3元素
        int[] sortedArray3 = Arrays.stream(elements)
                .mapToInt(Element::arr3Val)
                .toArray();

        // 输出结果：[2, 1, 3, 0, 4]
        System.out.println(Arrays.toString(sortedArray3));
    }
}

如果是Java 16之前的版本，用二维数组也能实现：

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

public class LinkedArraySort {
    public static void main(String[] args) {
        int[] array1 = {0, 1, 1, 1, 0};
        int[] array2 = {5, 3, 4, 2, 0};
        int[] array3 = {0, 1, 2, 3, 4};

        // 用二维数组打包每个位置的三个元素
        Integer[][] elements = new Integer[array1.length][3];
        for (int i = 0; i < array1.length; i++) {
            elements[i][0] = array1[i];
            elements[i][1] = array2[i];
            elements[i][2] = array3[i];
        }

        // 自定义排序逻辑
        Arrays.sort(elements, new Comparator<Integer[]>() {
            @Override
            public int compare(Integer[] o1, Integer[] o2) {
                // 先比较array1的值，降序
                int arr1Cmp = Integer.compare(o2[0], o1[0]);
                if (arr1Cmp != 0) {
                    return arr1Cmp;
                }
                // array1值相同时，比较array2的值，降序
                return Integer.compare(o2[1], o1[1]);
            }
        });

        // 提取排序后的array3
        int[] sortedArray3 = new int[array3.length];
        for (int i = 0; i < elements.length; i++) {
            sortedArray3[i] = elements[i][2];
        }

        System.out.println(Arrays.toString(sortedArray3));
    }
}

Python 实现示例 #

Python的实现会更简洁，利用zip打包数组，再通过lambda定义排序键：

array1 = [0, 1, 1, 1, 0]
array2 = [5, 3, 4, 2, 0]
array3 = [0, 1, 2, 3, 4]

# 打包三个数组的对应元素，按(-array1值, -array2值)排序（负号实现降序）
sorted_groups = sorted(zip(array1, array2, array3), key=lambda x: (-x[0], -x[1]))

# 提取排序后的array3元素
sorted_array3 = [group[2] for group in sorted_groups]
print(sorted_array3)  # 输出: [2, 1, 3, 0, 4]

这种方案的优势在于逻辑清晰，代码可读性强，而且能轻松适配不同的排序规则（比如把降序改成升序，只需要去掉负号或者调整Comparator的顺序）。

内容的提问来源于stack exchange，提问作者Joska