Question

我需要根据两个参数rank和dist（嵌入式排序）对元素进行排序。首先，必须按降序排列rank值的元素。其次，必须根据dist值按降序重新排序这些有序元素。

示例：

rank = [8.0, 2.0, 8.0, 5.0, 2.0]
dist = [1.2, 2.2, 3.1, 1.1, 0.8]

Step 1: ordered rank = [8.0, 8.0, 5.0, 2.0, 2.0], indexes = [0, 2, 3, 4, 1]

Step 2: ordered dist = [3.1, 1.2, 1.1, 2.2, 0.8], indexes = [2, 0, 3, 1, 4]

因此，最终结果为indexes = [2, 0, 3, 1, 4]。我们的想法是，在第2步中，我们只能交换那些具有相同排名的元素。

我当前的代码版本如下：

public static void main(String[] args) {    
    ArrayList<Double> rank = new ArrayList<Double>();
    rank.add(8.0);
    rank.add(2.0);
    rank.add(5.0);
    rank.add(1.0);
    rank.add(2.0);
    rank.add(8.0);

    ArrayList<Double> dist = new ArrayList<Double>();
    dist.add(1.8);
    dist.add(2.8);
    dist.add(1.1);
    dist.add(2.1);
    dist.add(2.2);
    dist.add(1.5);

    ArrayList<ArrayList<Double>> result = new ArrayList<ArrayList<Double>>();
    result.add(0,rank);
    result.add(1,dist);

    System.out.println(result.get(0));

    ArrayList<Double> nstore1 = new ArrayList<Double>(result.get(0));
    Collections.sort(result.get(0));
    int[] indexes1 = new int[result.get(0).size()];
    for (int n = 0; n < result.get(0).size(); n++){
        indexes1[n] = nstore1.indexOf(result.get(0).get(result.get(0).size()-n-1));
    }
    System.out.println(Arrays.toString(indexes1));

}

我遇到了第2步。如何在考虑排名顺序的情况下对dist的元素进行重新排序？任何直观的例子都将受到高度赞赏。

Answer 1

您需要创建自己的对象，而不是使用基元，而comparators则可以帮助您排序。

Answer 2

好的，这就是我发明的：

package test;

import java.util.ArrayList;
import java.util.Arrays;

public class Test {

   public static void main(String[] args) {
      ArrayList<Double> r = new ArrayList<Double>();
      r.add(8.0);
      r.add(2.0);
      r.add(5.0);
      r.add(1.0);
      r.add(2.0);
      r.add(8.0);
      ArrayList<Double> d = new ArrayList<Double>();
      d.add(1.8);
      d.add(2.8);
      d.add(1.1);
      d.add(2.1);
      d.add(2.2);
      d.add(1.5);
      Double[] rank = r.toArray(new Double[r.size()]);
      Double[] dist = d.toArray(new Double[d.size()]);
      Arrays.sort(rank);
      int fromIndex = -1;
      int indexes = 0;
      double lastValue;
      for (int a = 0; a < rank.length; a++) {
         lastValue = rank[a];
         if (lastValue == rank[a]) {
            if (fromIndex == -1) {
               fromIndex = a;
            }
            indexes++;
         } else {
            Arrays.sort(rank, fromIndex, indexes);
            fromIndex = -1;
            indexes = 0;
         }
      }
      System.out.println("Rank: " + Arrays.toString(rank));
      System.out.println("Dist: " + Arrays.toString(dist));
   }
}

我不确定这是不是你在想，所以让我知道它是否正常。编写比较器以减少方式排序数组将是你的任务（因为你的问题是一个家庭作业问题）。

Answer 3

import java.util.Arrays;

public class SortObject {

    public static void main(String args[]) {

        Student[] students = new Student[4];

        Student one = new Student(8.0, 1.8);
        Student two = new Student(2.0, 2.8);
        Student three = new Student(5.0, 1.1);
        Student four = new Student(1.0, 2.1);

        students[0] = one;
        students[1] = two;
        students[2] = three;
        students[3] = four;

        // Arrays.sort(students, Student.StudentComparator); // to sort on basis
        // of both rank and dist

        Arrays.sort(students);

        int i = 0;
        for (Student temp : students) {
            System.out.println("fruits " + ++i + " : " + temp.getRank()
                    + ", Quantity : " + temp.getDist());
        }

    }
}

复制并试试这个。让我知道它解决了问题。

import java.util.Comparator;

public class Student implements Comparable<Student> {

    private Double rank;
    private Double dist;

    public Student(double rank, double dist) {

        this.rank = rank;
        this.dist = dist;

    }

    public Double getRank() {
        return rank;
    }

    public Double getDist() {
        return dist;
    }

    public int compareTo(Student student) {

        return (int) (student.rank - this.rank);

    }

    public static Comparator<Student> StudentComparator = new Comparator<Student>() {

        public int compare(Student student1, Student student2) {

            Double first = student1.dist;
            Double second = student2.dist;

            return (int) (second - first);

        }

    };
}

Answer 4

由于这显然是一个家庭作业问题，我不会给你一个完整的答案。

我同意其他人说你必须写自己的Comparator。我认为这实际上是一个非常好的问题，迫使你以面向对象的方式思考。您需要首先考虑这个问题中的基本数据单元（基本Java类）。提示：它与数据的呈现方式完全正交。

ArrayList元素的嵌入式排序

4 个答案: