如何通过保存初始索引按列值对二维数组进行排序答案

【问题标题】：How To Sort 2d array by column value with saving initial indexing如何通过保存初始索引按列值对二维数组进行排序
【发布时间】：2022-01-07 04:00:49
【问题描述】：

我希望根据第一列中的值对以下数组进行排序，并在输入二维数组中保存行的初始位置。

int [][]intervals =
{
    {3,4},
    {2,3},
    {1,2},
};

输出将是

{1,2,2}
{2,3,1}
{3,4,0}

这里的第三列是输入二维数组中行的初始位置。

【问题讨论】：

标签： java arrays sorting matrix data-structures

【解决方案1】：

您可以利用Arrays.sort 并相应地传递Comparator。这将适用于您的情况：

        int [][] intervals =
                {
                        {3,4},
                        {2,3},
                        {1,2},
                };

        int mRows = intervals.length;
        int nCols = intervals[0].length;

        int [][]intervalsNew = new int[mRows][nCols + 1];

        for (int i = 0; i < mRows; i++) {
            intervalsNew[i] = Arrays.copyOf(intervals[i], nCols + 1);
            intervalsNew[i][nCols] = i;
        }

        Arrays.sort(intervalsNew, new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return Double.compare(a[1], b[1]);
            }
        });

        for (int i = 0; i < mRows; i++) {
            System.out.println(Arrays.toString(intervalsNew[i]));
        }

输出：

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

【讨论】：

【解决方案2】：

我对某些方法的了解比 mantri 少，因此我在这里严重依赖流，并且代码更冗长。这是我的尝试：

public class Intervals {

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

    // Convert to List to make easier to work on.
    List<List<Integer>> outer = new ArrayList<>();
    for (int[] x : intervals) {
        List<Integer> inner = new ArrayList<>();
        for (int y : x) {
        inner.add(y);
        }
        outer.add(inner);
    }

    // Create list of ints 0,1,2,3 to add to end.
    List<Integer> range = IntStream.rangeClosed(0, outer.size() - 1)
                                   .boxed()
                                   .collect(Collectors.toList());

    range.stream()
         .forEach(i -> {
             outer.get(i)
                  .add(i);
         });

    List<int[]> temp_new_intervals = new ArrayList<>();

    outer.stream()
         .sorted((c1, c2) -> {
             if (c1.get(0) > c2.get(0)) {
             return 1;
             } else if (c1.get(0) == c2.get(0)) {
             return 0;
             } else {
             return -1;
             }
         })
         .forEach(arr -> {
             // Because arr is Object [] we need to make it int[]
             Object[] objects = arr.toArray();
             int[] ints = Arrays.stream(objects)
                                .mapToInt(o -> (int) o)
                                .toArray();

             temp_new_intervals.add(ints);

         });

    int[][] new_intervals = new int[outer.size()][];

    for (int i = 0; i < outer.size(); i++) {
        new_intervals[i] = temp_new_intervals.get(i);
    }

    for (int[] x : new_intervals) {
        System.out.println(Arrays.toString(x));
    }

    }

}

输出：

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

【讨论】：