Java中基于索引数组对数组进行排序（类似于C#的Array.Sort()）答案

【问题标题】：Sort an array based on an index array in Java (similar to C#'s Array.Sort())Java中基于索引数组对数组进行排序（类似于C#的Array.Sort()）
【发布时间】：2013-08-31 18:53:39
【问题描述】：

我正在尝试在 Java 中找到一个解决方案来执行以下操作。

int [] keys = new int[]{7,9,4,2,8,5,6,0}; // not necessarily a continuous series
double [] vals = new double[]{10,31,20,22,21,30,33,34}; // same length as keys<br/>

我需要对keys（从低到高）进行排序，并按该顺序排列对应的vals。例如，这种情况下的输出将是，

sorted keys:   0,  2,  4,  5,  6,  7,  8,  9
ordered vals: 34, 22, 20, 33, 10, 30, 21, 31

我不能使用映射，因为在某些计算中我需要访问键和值，并给出像 keys[i] 或 vals[j] 这样的索引。

提前致谢，

【问题讨论】：

你为什么不使用 TreeMap 并相应地使用 i 和 j 插入键和值。因为你说keys.length和values.length是一样的。
A TreeMap 是 Map 并且 OP 说他不能使用 Map。
stackoverflow.com/questions/12824423/…
@BuhakeSindi OP 不使用 MAP 的原因对我来说没有多大意义。因为键和值的长度相同，索引也一样。
除了使用 ihsan 的答案和树形图之外，唯一的其他选择是自己编写排序，并且每当您进行交换时，也要交换另一个数组。

标签： java arrays sorting indexing

【解决方案1】：

创建一个包含字段键和值的类。然后实现 Comparable 接口。并覆盖 compareTo 方法。将您的对象存储在列表中并对其进行排序：Collections.sort(list)

【讨论】：

这将是我的解决方案。

【解决方案2】：

你实际上可以创建一对，然后像这样排序

Pair.java

class Pair
{
int key;
double val;

Pair()
{
}
Pair(int k,double v)
{
 key=k;
 val=v;
}
}

Main.java

 class Main
    {
     public static void main(String ar[])
     {
      int [] keys = new int[]{7,9,4,2,8,5,6,0}; 
      double [] vals = new double[]{10,31,20,22,21,30,33,34};
      Pair p[]=new Pair[keys.length];   //length of any array
      for(int i=0;i<p.length;i++)
      {
         p[i] = new Pair(keys[i],vals[i]);
      }
      Collections.sort(p,new CustomComparator);
     }
    }

CustomComparator.java

public class CustomComparator implements Comparator<Pair>
   {
      public int compare(Pair a, Pair b) {  
      if (a.key > b.key) {
         return 1;
      } else if (a.key < b.key) {
         return -1;
      }
      else
      return 0;
    }
}

【讨论】：

这个答案是提前 11 分钟提供的
您的比较器可以使用return a.key-b.key 或在Java 7 中使用Integers.compare(a.key, b.key) 进行整理。您也不能将Collections.sort 与数组一起使用。

【解决方案3】：

您可以通过自定义冒泡排序来做到这一点。运行我的代码

public class IndexSort {

public static void main(String[] args) {
    int[] keys = new int[]{7, 9, 4, 2, 8, 5, 6, 0}; // not necessarily a continuous series
    double[] vals = new double[]{10, 31, 20, 22, 21, 30, 33, 34};
    for (int i = 0; i < keys.length; i++) {
        for (int j = i+1; j < keys.length; j++) {
            if(keys[i]>keys[j]){
                 int temp=keys[i];
                keys[i]=keys[j];
                keys[j]=temp;
                double t=vals[i];
                vals[i]=vals[j];
                vals[j]=t;
            }                
        }
        System.out.print(keys[i]+" -> ");
        System.out.println("  "+vals[i]);
    }
}
}

这是演示解决方案。为了性能，您应该将此逻辑应用于其他算法。

【讨论】：

请注意，这对于大型集合来说会非常慢，因为冒泡排序是O(n^2) 最坏的情况。

【解决方案4】：

最简单的方法可能是首先将键/值对放入TreeMap，然后遍历该映射的Map.Entry 条目并重新编写每个键对。在伪代码中：

sortedMap = new TreeMap

for i between 0 and keys.length
    sortedMap.put(keys[i], vals[i])

i = 0
for entry in sortedMap:
    keys[i] = entry.getKey()
    vals[i] = entry.getValue()
    ++i

【讨论】：

【解决方案5】：

如果您没有重复的密钥（我假设您没有），那么将整个密钥都打入 TreeMap：

public static void main(String[] args) throws Exception {
    int[] keys = new int[]{7, 9, 4, 2, 8, 5, 6, 0};
    double[] vals = new double[]{10, 31, 20, 22, 21, 30, 33, 34};
    final Map<Integer, Double> m = new TreeMap<>();
    for (int i = 0; i < keys.length; ++i) {
        m.put(keys[i], vals[i]);
    }
    System.out.println(m);
}

输出：

{0=34.0, 2=22.0, 4=20.0, 5=30.0, 6=33.0, 7=10.0, 8=21.0, 9=31.0}
[34.0, 22.0, 20.0, 30.0, 33.0, 10.0, 21.0, 31.0]

Collection<Double>m.values() 将根据您的需要订购。

或者在你的元组周围创建一个包装类并对其中的List 进行排序：

public static void main(String[] args) throws Exception {
    int[] keys = new int[]{7, 9, 4, 2, 8, 5, 6, 0};
    double[] vals = new double[]{10, 31, 20, 22, 21, 30, 33, 34};
    final class Wrapper implements Comparable<Wrapper> {

        final int key;
        final double value;

        public Wrapper(int key, double value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public int compareTo(Wrapper o) {
            return Integer.compare(key, o.key);
        }

        @Override
        public String toString() {
            return "{key=" + key + ", value=" + value + "}";
        }
    }
    final List<Wrapper> wrappers = new ArrayList<>(keys.length);
    for (int i = 0; i < keys.length; ++i) {
        wrappers.add(new Wrapper(keys[i], vals[i]));
    }
    Collections.sort(wrappers);
    System.out.println(wrappers);
}

输出：

[{key=0, value=34.0}, {key=2, value=22.0}, {key=4, value=20.0}, {key=5, value=30.0}, {key=6, value=33.0}, {key=7, value=10.0}, {key=8, value=21.0}, {key=9, value=31.0}]

Collections.sort 是一种稳定的排序方式，因此它适用于重复项，并且它们的顺序不会改变。

【讨论】：

【解决方案6】：

在没有映射的情况下，最好的方法是交换 vals 数组的元素，同时在排序时交换 keys 数组的值。例如使用插入排序：

private void insertionSort(int[] keys, int[] values){
    for(int i = 0; i < keys.length; i++){
        int key = keys[i];
        int val = values[i];
        int index = i;

        while(index > 0 && key < keys[index - 1]){
            keys[index] = keys[index - 1];
            values[index] = values[index - 1];
            index--;
        }

        keys[index] = key;
        values[index] = val;
    }

}

【讨论】：

【解决方案7】：

这就是我的做法和工作方式：

创建一个 implements Comparable 的键值对持有者类。
将您的键值对类添加到列表中，并使用Collections.sort() 对其进行排序。

例子：

键值对类：

/**
 * @author Buhake Sindi
 * @since 28 August 2013
 *
 */
public class Pair implements Comparable<Pair> {

    private int key;
    private double value;

    /**
     * @param key
     * @param value
     */
    public Pair(int key, double value) {
        super();
        this.key = key;
        this.value = value;
    }

    /**
     * @return the key
     */
    public int getKey() {
        return key;
    }

    /**
     * @return the value
     */
    public double getValue() {
        return value;
    }

    /* (non-Javadoc)
     * @see java.lang.Comparable#compareTo(java.lang.Object)
     */
    public int compareTo(Pair o) {
        // TODO Auto-generated method stub
        if (getKey() > o.getKey()) {
            return 1;
        }

        if (getKey() < o.getKey()) {
            return -1;
        }

        return 0;
    }
}

测试用例：

/**
 * @author Buhake Sindi
 * @since 28 August 2013
 *
 */
public class PairComparer {

    public static void main(String[] args) {
        List<Pair> pairs = new ArrayList<Pair>(Arrays.asList(new Pair(7, 10d),
                                         new Pair(9, 31d),
                                         new Pair(4, 20d),
                                         new Pair(2, 22d),
                                         new Pair(8, 21d),
                                         new Pair(5, 30d),
                                         new Pair(6, 33d),
                                         new Pair(0, 34d)));
        Collections.sort(pairs);
        for (Pair pair : pairs) {
            System.out.println(pair.getKey() + " - " + pair.getValue());
        }
    }
}

输出：

0 - 34.0
2 - 22.0
4 - 20.0
5 - 30.0
6 - 33.0
7 - 10.0
8 - 21.0
9 - 31.0

希望这会有所帮助。

【讨论】：