排序2個維陣列中的Java - 跳過第一個索引

Question

我在爪哇的二維陣列，其看起來像這樣：

每個元素/作業具有：

• 工作號碼在index [0];
• 工作到達時間是在指數[1];和
• 工作突發時間指數[2]

jobs[0][0] = 1 
jobs[0][1] = 0 
jobs[0][2] = 5 

jobs[1][0] = 2 
jobs[1][1] = 2 
jobs[1][2] = 19 

jobs[2][0] = 3 
jobs[2][1] = 4 
jobs[2][2] = 10 

首先，我想這是根據索引根據到達時間對它們進行排序[1]所幸我沒有通過使用此代碼：

Arrays.sort(jobs, new Comparator<int[]>(){ 
    public int compare(int[] a, int[] b) { 
     return a[1] - b[1]; 
    } 
}); 

---

現在，我的問題是，我想將其排序accordin g到突發時間，根據指數[2]。這裏是TWIST ...我怎麼能夠根據突發時間（index [2]）對第一個元素進行排序呢？ 我希望job [0]保留在數組的頂部，並按索引[2]對其餘元素進行排序 - 突發時間。像這樣：

jobs[0][0] = 1 
jobs[0][1] = 0 
jobs[0][2] = 5 

jobs[1][0] = 3 
jobs[1][1] = 4 
jobs[1][2] = 10 

jobs[2][0] = 2 
jobs[2][1] = 2 
jobs[2][2] = 19 

該作業正在按照突發時間進行排序，job1保持在最前。 通過我上面提供的代碼來實現它會更好。感謝

Answer 1

一個不重要的方法是：

int firstBurst = jobs[0][2]; 
jobs[0][2] = Integer.MIN_VALUE; 
Arrays.sort(jobs, new Comparator<int[]>(){ 
    public int compare(int[] a, int[] b) { 
     // don't use subtraction, this can lead to underflows 
     return a[2] < b[2] ? -1 : (a[2] == b[2] ? 0 : 1); 
    } 
}); 
jobs[0][2] = firstBurst; 

只需設置的第一個項目的突發Integer.MIN_VALUE（整數等效負無窮大的）。這樣，它保證了第一個項目是最小的，所以排序後它仍然是第一個元素。排序後，將第一項的突發重置爲其原始值。

編輯

通過檢查documentation驗證Arrays.sort是穩定的，我無意中發現瞭解決這個問題的最簡單的版本：使用

Arrays.sort(T[] a, 
      int fromIndex, 
      int toIndex, 
      Comparator<? super T> c) 

那麼你可以直接做到這一點：

Arrays.sort(jobs, 1, jobs.length, new Comparator<int[]>(){ 
    public int compare(int[] a, int[] b) { 
     // don't use subtraction, this can lead to underflows 
     return a[2] < b[2] ? -1 : (a[2] == b[2] ? 0 : 1); 
    } 
}); 

Answer 2

首先，你應該使用集合而不是數組。第二，你不應該使用數組時，你可以使用一個對象：

public class Job { 
    private int number; 
    private int arrival; 
    private int burst; 

    // constructor and getters omitted for brevity. 
} 

然後，您可以有一個List<Job>，而不是int[][]。只要看看結構的類型，它就更清晰，更具可讀性。命名屬性，可能具有不同類型，並且可以使用方法添加行爲，這是OO的一部分。比int[]更具可讀性，安全性和可維護性。

的好消息是，一個列表比數組更多的功能。所以你可以舉個例子，取一個子列表，並對該子列表進行排序：

List<Job> jobsExceptFirstOne = allJobs.subList(1); 
Collections.sort(jobsExceptFirstOne, new Comparator<Job>() { 
    @Override 
    public int compare(Job left, Job right) { 
     return Integer.compare(left.getBurst(), right.getBurst()); 
    } 
}); 

Voilà。問題解決了。

Answer 3

也許會有用這個的一種方式：

final Integer job1 = Integer.valueOf(jobs[0][0]); 
final Integer job2 = Integer.valueOf(jobs[0][1]); 

return job1.compareTo(job2); 

我真的不知道，如果的valueOf（工種[0] [0]）會更大接着調用valueOf（工種[0] [1]） ，我真的不知道他們是如何站在一個又一個的，但他們之間必定有差異，並且應該能夠根據返回的數字是大於還是小於那個工作來排序它們[ 0] [0]，作業[1] [0]，等等

Answer 4

使用比較taht記得第一個作業的作業號，並把該作爲最小之前檢查突發時間。

public class MyComparator implements Comparator<int[]> { 

    private final int firstJob; 

    public MyComparator(int firstJob) { 
     this.firstJob = firstJob; 
    } 

    public int compare(int[] a, int[] b) { 
     if (a[0] == b[0]) { 
      return 0; 
     } 
     if (a[0] == firstJob) { 
      return -1; 
     } 
     if (b[0] == firstJob) { 
      return 1; 
     } 
     return Integer.compare(a[2], b[2]); 
    } 
} 

Answer 5

正如其他人說，你應該用更智能的集合，而不是數組，如果你真的想用目前的代碼，你可以使用類似：

final int[][] jobs = new int[][]{{1,0,5},{2,2,19},{3,4,10}}; 

Arrays.sort(jobs, new Comparator<int[]>(){ 
    public int compare(int[] a, int[] b) { 
     if(Arrays.equals(a, jobs[0])) 
     return -1; 
     else 
     return a[2] - b[2]; 
    } 
}); 

System.out.println(jobs[0][2]); 
System.out.println(jobs[1][2]); 
System.out.println(jobs[2][2]); 

唯一的缺點是你的陣列需要是final。