java - 在Java中对3维数组进行排序

Question

我有一个由矩阵组成的三维 int 数组(立方体)。我的问题是，我想创建一个新的三维数组，其中我将使用插入排序按最高值对矩阵进行排序。我不想在新的多维数据集中保存值，但我想仅保存矩阵的数量。这是一些例子，我想怎么做。希望你能理解我的想法:

int[][] matrix1={{10,50,10},{3,5,1},{100,500,800}};
int[][] matrix2={{30,30,30},{3,3,3},{300,300,300}};
int[][] matrix3={{20,20,20},{2,2,2},{200,200,200}};
int[][][] nonSortedMatrices={matrix1,matrix2,matrix3};

现在我想这样排序:

int[][] matrixWithHighestValue={{2,1,2},{2(or 1),1,2},{2,1,1}};
int[][] matrixSecHighestValue={{3,2,3},{1(or2),2,3},{3,2,2}};
int[][] matrixWithLowestValue={{1,3,1},{3,3,1},{1,3,3}};
int[][][] sortedMatrices={matrixWithHighestValue,matrixSecHighestValue,matrixWithLowestValue};

就是这样。希望它是清楚的。矩阵matrixWithHighestValue将在每个地方包含三个(在本例中)矩阵中每个地方的最佳选择，我正在思考如何做几个小时，但我无法解决这个问题。只是认为我想使用的是插入排序，因为它是最快的方法，因为数据不是那么大。 我将非常感谢每一个建议。

Answer 1

注意:这假设所有矩阵都具有相同的维度。

我很难想到一种简单的方法将 (10, 30, 20) 排序为索引顺序 (最高、第二高、最低) 或 (2, 3, 1)，但这种内部类 + 辅助方法似乎做得很好。

主要方法扫描未排序矩阵并同时构建排序矩阵。

public class MatrixSorter {

    static class IntPos {
        public int num, pos;

        IntPos(int num, int pos) {
            this.num = num;
            this.pos = pos;
        }

        @Override
        public String toString() {
            // For testing purposes to use Arrays.toString
            return String.valueOf(pos + 1);
        }
    }

    private static int[] getSortedPositions(int[] nums) {
        IntPos[] positions = new IntPos[nums.length];

        for (int i = 0; i < nums.length; i++) {
            positions[i] = new IntPos(nums[i], i);
        }

        Arrays.sort(positions, new Comparator<IntPos>() {
            @Override
            public int compare(IntPos o1, IntPos o2) {
                return -1 * Integer.compare(o1.num, o2.num);
            }
        });

        int[] sortedPos = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            sortedPos[i] = positions[i].pos + 1;
        }

        return sortedPos;
    }

    public static void main(String[] args) {
        int[][] matrix1 = {{10, 50, 10}, {3, 5, 1}, {100, 500, 800}};
        int[][] matrix2 = {{30, 30, 30}, {3, 3, 3}, {300, 300, 300}};
        int[][] matrix3 = {{20, 20, 20}, {2, 2, 2}, {200, 200, 200}};
        int[][][] nonSortedMatrices = {matrix1, matrix2, matrix3};

        final int MATRIX_SIZE = nonSortedMatrices.length;
        int[][][] sortedMatrices = new int[MATRIX_SIZE][MATRIX_SIZE][MATRIX_SIZE];

        for (int r = 0; r < MATRIX_SIZE; r++) {
            for (int c = 0; c < MATRIX_SIZE; c++) {

                int[] nums = new int[MATRIX_SIZE];
                for (int d = 0; d < MATRIX_SIZE; d++) {
                    nums[d] = nonSortedMatrices[d][r][c];
                }
                int[] sortedPos = getSortedPositions(nums);

                for (int d = 0; d < MATRIX_SIZE; d++) {
                    sortedMatrices[d][r][c] = sortedPos[d];
                }
            }
        }
    }
}

打印出排序后的矩阵看起来像这样

for (int r = 0; r < MATRIX_SIZE; r++) {
    for (int c = 0; c < MATRIX_SIZE; c++) {
        System.out.print(Arrays.toString(sortedMatrices[r][c]) + " ");
    }
    System.out.println();
}

输出看起来像您在问题中想要的内容，而无需单独的 int[][] 值。

[2, 1, 2] [1, 1, 2] [2, 1, 1] 
[3, 2, 3] [2, 2, 3] [3, 2, 2] 
[1, 3, 1] [3, 3, 1] [1, 3, 3]