ArrayList元素的嵌入式排序

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

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 2

而不是使用基元，你需要創建自己的對象，並來幫助你排序。

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

林不知道這是自己所想的，所以讓我知道，如果它的好。編寫比較器會以減少的方式對數組進行排序將是您的任務（因爲您的問題是一個作業問題）。

Answer 4

由於這顯然是一個作業問題，我不會給你一個完整的答案。

我同意其他人說你必須自己編寫Comparator s。我認爲這實際上是一個很好的問題，迫使你以面向對象的方式進行思考。您需要首先考慮這個問題中的基本數據單元（基本Java類）是什麼。提示：它與數據呈現的方式完全正交。