如何在Java中找到排序的排列

我想对数组进行排序，并按排序顺序查找每个元素的索引。 例如，如果我在阵列上运行此命令：

[3,2,4]

我会得到：

[1,0,2]

[1,0,2]

---

在Java中有没有一种简单的方法可以做到这一点？

让我们假设元素存储在一个数组中

final int[] arr = // elements you want
List<Integer> indices = new ArrayList<Integer>(arr.length);
for (int i = 0; i < arr.length; i++) {
  indices.add(i);
}
Comparator<Integer> comparator = new Comparator<Integer>() {
  public int compare(Integer i, Integer j) {
    return Integer.compare(arr[i], arr[j]);
  }
}
Collections.sort(indices, comparator);

final int[]arr=//需要的元素
列表索引=新的ArrayList（arr.length）；
对于（int i=0；i

现在，

索引

按排序顺序包含数组的索引。您可以使用足够简单的

for

循环将其转换回

int[]

。

import java.util.*；
import java.util.*;
public class Testing{
   public static void main(String[] args){
       int[] arr = {3, 2, 4, 6, 5};
       TreeMap map = new TreeMap();
       for(int i = 0; i < arr.length; i++){
            map.put(arr[i], i);
       }
       System.out.println(Arrays.toString(map.values().toArray()));
   }
}

公共类测试{
公共静态void main（字符串[]args）{
int[]arr={3,2,4,6,5}；
TreeMap map=newtreemap（）；
对于（int i=0；i

实现这一点的一种方法是制作一个配对列表，起始索引作为配对的第二部分。按字典顺序对成对列表进行排序，然后从排序后的数组中读取起始位置

起始阵列：

[3,2,4]

添加具有起始索引的对：

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

分类

然后读出每对的第二部分

import java.io.*；
公共类样本{
公共静态void main（字符串[]args）{
int[]data={0,3,2,4,6,5,10}；//大小写：范围0-10
int i，范围高=10；
int[]秩=新int[rangeHigh+1]；
//计数排序
对于（i=0；i对于（i=0；i作为更新，在Java8中使用streams API相对容易做到这一点

public static int[] sortedPermutation(final int[] items) {
  return IntStream.range(0, items.length)
    .mapToObj(value -> Integer.valueOf(value))
    .sorted((i1, i2) -> Integer.compare(items[i1], items[i2]))
    .mapToInt(value -> value.intValue())
    .toArray();
}

不幸的是，索引需要装箱和拆箱步骤，因为在
IntStream
上没有
.sorted（IntComparator）
方法，甚至没有
IntComparator
功能接口

要概括为
可比对象的
列表
，非常简单：

public static <K extends Comparable <? super K>> int[] sortedPermutation(final List<K> items) {
  return IntStream.range(0, items.size())
    .mapToObj(value -> Integer.valueOf(value))
    .sorted((i1, i2) -> items.get(i1).compareTo(items.get(i2)))
    .mapToInt(value -> value.intValue())
    .toArray();
}

public static我限制自己根本不使用番石榴，我会让你知道；）启用这样一种情况，你已经知道它只是数据范围内的一个数字。如果数据范围非常大，这会变得非常昂贵。例如，int[]data={0，Integer.MAX_VALUE}；投赞成票。但问题是地图的键中不允许有重复的元素。@Shengyuan Lu您关于重复的看法是对的。如果输入是{3,2,4,3,3}，那么我的结果将是[1,4,2]，Louis Wasserman的结果将是[1,0,3,4,2]。我想知道491880用户喜欢哪一个？
public static int[] sortedPermutation(final int[] items) {
  return IntStream.range(0, items.length)
    .mapToObj(value -> Integer.valueOf(value))
    .sorted((i1, i2) -> Integer.compare(items[i1], items[i2]))
    .mapToInt(value -> value.intValue())
    .toArray();
}

public static <K extends Comparable <? super K>> int[] sortedPermutation(final List<K> items) {
  return IntStream.range(0, items.size())
    .mapToObj(value -> Integer.valueOf(value))
    .sorted((i1, i2) -> items.get(i1).compareTo(items.get(i2)))
    .mapToInt(value -> value.intValue())
    .toArray();
}