0

我需要根据两个参数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));

}

dist我被第2步卡住了。如何在考虑等级顺序的同时对元素进行重新排序？任何直观的例子都将受到高度赞赏。

4

4 回答 4

1

您需要创建自己的对象和比较器来帮助您进行排序，而不是使用原语。

于 2013-04-03T15:48:40.640 回答
1

好的，这就是我发明的：

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));
   }
}

我不确定这是否是您的想法，因此请告诉我是否可以。编写以递减方式对数组进行排序的比较器将是您的任务（因为您的问题是家庭作业问题）。

于 2013-04-03T15:49:32.523 回答
1 
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);

        }

    };
}
于 2013-04-03T16:19:56.540 回答
0

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

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

于 2013-04-03T16:01:30.697 回答