Question

我想知道是否有更好的方法可以做到这一点，使用数字对。我正在解决CodeAbbey上的问题。这个是

对这些数字进行排序，然后打印出原始索引位置。

我是这样做的。（我还在学习。）

public static void bSort(int[][] a) {
    boolean sorted = false;
    int temp;
    int temp2;

    while (!sorted) {
        int counter = 0;

        for (int i = 0; i < a.length - 1; i++) {
            if (a[i][0] > a[i + 1][0]) {
                temp = a[i][0];
                temp2 = a[i][1];
                a[i][0] = a[i + 1][0];
                a[i + 1][0] = temp;

                a[i][1] = a[i + 1][1];
                a[i + 1][1] = temp2;
                counter++;
            }
        }
        if (counter == 0) {
            sorted = true;
        }
    }
    for (int i = 0; i < a.length; i++) {
            System.out.print(a[i][1] + " ");
    }
}

我一直在搜索这个： Sort a Map<Key, Value> by values (Java)但我尚未使用地图。

Answer 1

您可以创建一个包含一对整数的类：

class Pair implements Comparable<Pair>{

    int number, index;

    @Override
    public int compareTo(Pair other){
        return Integer.compare(number, other.number);
    }
}

然后你可以像这样对一对Pair数组进行排序：

Pair[] pairs = new Pair[]; // initialize with values
Arrays.sort(pairs);

这将根据Pair对数组或number进行排序，如果您之后迭代它，则可以获得每个index的{{1}}

或者，您可以在Pair类

之外实现Comparator接口

Pair

并像这样使用

class PairComparator implements Comparator<Pair> {
    @Override
    public int compare(Pair a, Pair b) {
        return Integer.compare(a.number, b.number);
    }
}

Answer 2

有很多方法可以解决任何特定问题。虽然在你的学习曲线中可能看起来有点早，但我建议你习惯Java 8流和lambdas。一旦你习惯了它们，你会发现它们是解决许多问题的自然方式。

所以这是一个基于流的解决方案，我将解释你的问题：

void printSortedIndexes(int[] list) {
    IntStream.range(0, list.length).boxed()
        .sorted(Comparator.comparingInt(n -> list[n]))
        .forEach(System.out::println);
}

这可以解释为：创建一个从0到列表长度的整数流 - 1，转换为Integer个对象的流，通过比较列表中该索引的整数对它们进行排序，然后将它们打印出来。我认为这比存储索引和手动排序更好。

Answer 3

它至少可能比两个相同长度的并行阵列更好。＆＃34;大概＆＃34;因为a[indices[i]] - 排列方法 - 也是一个很好的解决方案。

其他答案已经提到了一些方法。

您的方法会更多地使用int[]对

public static void bSort(int[][] a) {
    boolean sorted = false;
    int fromI = 0;
    while (!sorted) {
        boolean changed = false;
        for (int i = fromI; i < a.length - 1; i++) {
            int[] current = a[i];
            int[] next = a[i + 1];
            if (current[0] > next[0]) {
                int temp = current[0];
                int temp2 = current[1];
                current[0] = next[0];
                current[1] = next[1];
                next[0] = temp;
                next[1] = temp2;
                if (!changed) {
                    fromI = i;
                    changed = true;
                }
            }
        }
        if (!changed) {
            sorted = true;
        }
    }
    for (int[] current : a) {
        System.out.print(current[1] + " ");
    }
}

在上面：

在循环中声明变量没有任何惩罚，完全相同。
可以使用System.arrayCopy。
temp / temp2也可以是一个int[]，但最好在循环外创建。

Answer 4

以下是使用地图

的解决方案

Map<Integer, Integer> toBeSorted = new HashMap<>();

toBeSorted.put(1, -2);
toBeSorted.put(2, -1);
toBeSorted.put(3, 8);
toBeSorted.put(4, 7);
toBeSorted.put(5, 6);
toBeSorted.put(6, 500);
toBeSorted.put(7, 4);
toBeSorted.put(8, 3);
toBeSorted.put(9, 2);
toBeSorted.put(10, 1);

final Comparator<Map.Entry<Integer, Integer>> comparator =

    new Comparator<Map.Entry<Integer, Integer>>() {

  @Override
  public int compare(Map.Entry<Integer, Integer> o1,
                     Map.Entry<Integer, Integer> o2) {
    return o1.getValue().compareTo(o2.getValue());
  }

};//Comparator

//need a List to keep contract with Collections.sort()
final List<Map.Entry<Integer, Integer>> list =
    new ArrayList<>(toBeSorted.entrySet());

//invoke sort 
Collections.sort(list, comparator);

for(Map.Entry<Integer, Integer> entry : list) {
  System.out.println(entry.getKey() + " -> " + entry.getValue());
}

打印出来：

1 -> -2
2 -> -1
10 -> 1
9 -> 2
8 -> 3
7 -> 4
5 -> 6
4 -> 7
3 -> 8
6 -> 500

对一对或多个整数进行排序。有比阵列更好的方法吗？

4 个答案:

以下是使用地图