ArrayList 元素的嵌入式排序答案

【问题标题】：Embedded ordering of elements of ArrayListArrayList 元素的嵌入式排序
【发布时间】：2013-04-03 15:45:05
【问题描述】：

我需要根据两个参数对元素进行排序，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？任何直观的例子都将受到高度赞赏。

【问题讨论】：

我觉得自己写比较器会更好。
@Achintya Jha：如何做到这一点，以便在第 2 步中我们只能交换那些具有相同等级的元素？

标签： java sorting collections arraylist

【解决方案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);

        }

    };
}

【讨论】：

你刚刚回答了他的作业问题。现在他只会复制这个而不是学习一些东西。
可以通过dist 和rank 使用单一方法进行排序。
@toto2 是的，我为那个写了代码。否则 Array.sort() 可以很好地用于单双数组。
谢谢。我检查了你的代码。事实上，它是按第一个参数排序的，但它没有按照我的示例的第 2 步排序。好吧，我会自己想办法。

【解决方案2】：

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

【讨论】：

【解决方案3】：

好的，这就是我发明的：

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

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

【讨论】：

如果你能发布一个有两个参数的例子就好了。嗯，地图很好。谢谢。
虽然你可以让它与地图一起工作，但这不是一个优雅的解决方案，更不用说反OO了。

【解决方案4】：

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

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

【讨论】：