Question

我是Java的新手。我试图根据数组val []的值对数组arr []进行排序，它应该保持插入顺序。

int arr[] = {2,3,2,4,5,12,2,3,3,3,12};
int val[] = {3,4,3,1,1,2,3,4,4,4,2};

我正在使用它：

ArrayList <Integer> al = new ArrayList <Integer> () ;
for(int i = 0 ; i < arr.length ; i++)
al.add(arr);
Collections.sort(al , (left , right) -> val[al.indexOf(left)]  -
val[al.indexOf(right)])

我的输出应该是

4 5 12 12 2 2 2 3 3 3 3

Answer 1

val数组似乎是一个元素。

    int[] arr = {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12};
    int[] val = {3, 4, 3, 1, 1, 2, 2, 3, 4, 4, /*4,*/ 2};
    int[] sortedArr = IntStream.range(0, arr.length)
            .mapToObj(i -> new int[] {arr[i], val[i]})
            .sorted((lhs, rhs) -> Integer.compare(lhs[1], rhs[1]))
            .mapToInt(pair -> pair[0])
            .toArray();
    System.out.println(Arrays.toString(sortedArr));

导致

[4, 5, 12, 2, 12, 2, 2, 3, 3, 3, 3]

由于排序是稳定的，可以做两种排序或组合它们：

    int[] sortedArr = IntStream.range(0, arr.length)
            .mapToObj(i -> new int[] {arr[i], val[i]})
            .sorted((lhs, rhs) -> Integer.compare(lhs[0], rhs[0]))
            .sorted((lhs, rhs) -> Integer.compare(lhs[1], rhs[1]))
            .mapToInt(pair -> pair[0])
            .toArray();

然后，瞧

[4, 5, 2, 12, 12, 2, 2, 3, 3, 3, 3]

Answer 2

只需编写您选择的排序算法，比较val中的值，并相应地对arr和val进行排序。

仅仅为了简洁起见，这是一个使用冒泡排序的例子：

static void sortByVal(int[] arr, int[] val) {

    if (arr.length != val.length) { return; }        

    for (int i=0; i < val.length; i++) {
        for (int j=1; j < (val.length-i); j++) {
            if (val[j-1] > val[j]) {

                int temp = val[j-1];  
                val[j-1] = val[j];  
                val[j] = temp;

                temp = arr[j-1];  
                arr[j-1] = arr[j];  
                arr[j] = temp;
            }
        }  
    }  
}

但是请注意，您通常不应该重新实现排序算法，而是切换到适当的数据结构。

例如，不使用键数组和values-array，而是使用包含键值对的数组。然后可以轻松地对此数组进行排序：

Collections.sort(array, (p0, p1) -> Integer.compare(p0.val, p1.val));

Answer 3

你的两个数组的长度不同，所以这会失败，但如果你解决了这个问题，这应该可行：

static <T extends Comparable<T>> List<Integer> getSortOrder(List<T> list) {
    // Ints in increasing order from 0. One for each entry in the list.
    List<Integer> order = IntStream.rangeClosed(0, list.size() - 1).boxed().collect(Collectors.toList());
    Collections.sort(order, (o1, o2) -> {
        // Comparing the contents of the list at the position of the integer.
        return list.get(o1).compareTo(list.get(o2));
    });
    return order;
}

// Array form.
static <T extends Comparable<T>> List<Integer> getSortOrder(T[] list) {
    return getSortOrder(Arrays.asList(list));
}

static <T> List<T> reorder(List<T> list, List<Integer> order) {
    return order.stream().map(i -> list.get(i)).collect(Collectors.toList());
}

// Array form.
static <T> T[] reorder(T[] list, List<Integer> order) {
    return reorder(Arrays.asList(list), order).toArray(list);
}


public void test(String[] args) {
    Integer arr[] = {2,3,2,4,5,12,2,3,3,3,12};
    Integer val[] = {3,4,3,1,1,2,2,3,4,4,4,2};
    List<Integer> sortOrder = getSortOrder(val);
    Integer[] reordered = reorder(arr, sortOrder);
    System.out.println(Arrays.toString(reordered));
}

Answer 4

你应该看看你的逻辑

val [0] = arr [3] = 4
val [1] = arr [4] = 5

val [2] = arr [3]当前模式后的值为4。

要获得12所需的值，您必须删除以前使用的4,5

这种模式与val [1]所做的相矛盾，因为4没有被删除。

如何根据Java中其他数组的值对一个数组进行排序？

4 个答案: